Bemelegítés: Válasszunk ki egész számokat egy intervallumban tartományban 1 és 35 között
import random
print(random.randint(1,35))
Ha ki akarjuk zárni az ismétléseket akkor berakjuk egy változóba
#Skandinávlottó
import random #Csomag importálása
hány_számból = 35 #Értékadások
hány_számot = 7
random.seed() #Inicializálás
halmaz=set()
while len(halmaz)<hány_számot: #Feltétel
halmaz.add (random.randint(1,hány_számból))
számlista = sorted(list(halmaz)) #Számok tárolás további felhasználásra
print("A heti Skandinávlottó számok: ", ", ".join(str(szám) for szám in számlista))
próba:
A heti Skandinávlottó számok: 4, 6, 13, 18, 19, 29, 31
-------------------https://www.programiz.com/python-programming/online-compiler/--------------
A következő feladat
Egy általunk készített oldal sok munkaórába kerül. szeretnénk megvédeni a rosszindulatú felhasználóktól, ezt jelszavas védelem segítségével tehetjük meg. Hogyan generálhatnánk biztonságos jelszót az anyagaink védelmére?
Hozzunk létre egy véletlenszerű jelszó-generáló programot python programozási nyelven!
Kezdjük az algoritmussal
Első lépésként a Python könyvtár eléréséhez importálnunk kell a csomagot a Python szkriptünkbe.
véletlenszerű import karakterlánc importálása
Ha elkészült, köszöntsük a felhasználót!
nyomtatás ('hello, Üdvözöljük a Jelszógenerátorban!')
Ezután kérdezzük meg a felhasználótól a jelszó hosszát.
length = int (input ('Adja meg a jelszó hosszát:'))
Ideje meghatározni az adatokat. string Ugyanezt a modult fogjuk használni.
alsó = string.ascii_lowercase
felső = string.ascii_uppercase
szám = string.digits
szimbólumok = string.punctuation
Tároltunk kis- és nagybetűket, valamint számokat és szimbólumokat.
Egyesítsük az adatokat és tároljuk az adatokat.
minden = alsó + felső + num + szimbólum
Most, hogy megvan az adat, használjuk ki a random modult a jelszó előállításához.
temp = random.sample (all, length)
jelszó = "". csatlakozzon (temp)
Átadjuk az összesített adatokat a jelszó hosszával együtt, és a végén összekapcsoljuk őket.
Most, hogy tisztában van a forgatókönyvvel, akár csökkenthetjük is a kódsorok számát azáltal,
hogy megszüntetjük az adatok tárolását. Nézzük meg.
all = string.ascii_letters + string.digits + string.punctuation
pass = "" .join (random.sample (all, length))
Végül nyomtassuk ki a jelszót!
nyomtatás (jelszó)
Nézzünk néhány minta kimenetet:
-------------
Valósítsuk meg Pythonban a leírtakat:
import random
import string
print('Jelszó generátor!')
length = int(input('A jelszó hossza: '))
lower = string.ascii_lowercase
upper = string.ascii_uppercase
num = string.digits
symbols = string.punctuation
all = lower + upper + num + symbols
temp = random.sample(all,length)
password = "".join(temp)
print(password)
-------------------https://www.programiz.com/python-programming/online-compiler/------------------------
------------------------------------
Finomítsuk a programunkat, kérdezze meg melyik karaktertípusból hányat szeretnénk hogy tartalmazzon a jelszavunk!
A programunk forrása így alakul
Most gondolkozzunk visszafelé, a program alapján írjuk le az algoritmusát, a megjegyzések alapján könnyű dolgunk lesz.
import random
import secrets
import string
# Számok
digits = string.digits
# Kis nagy betű
letters = string.ascii_lowercase
# Szimbólumok
symbols = "!#$%&'()*+, -./:;<=>?@[\]^_`{|}~"
password = ''.join(secrets.choice(digits + letters + symbols) for t in range(20))
def message():
print("Helló ez egy jelszőgenerátor: ")
print("Miből mennyit tartalmazzon?")
print(userGen())
def userGen():
upper = int(input("Kisbetű? "))
spec = int(input("Hány szimbólum? "))
num = int(input("Hány számot akarsz? "))
return passGen(upper,spec,num)
def passGen(upper,spec,num):
new_password = ""
for i in range(upper):
new_password += random.choice(letters)
for x in range(spec):
new_password += random.choice(symbols)
for y in range(num):
new_password += random.choice(digits)
pass_word = list(new_password)
shuff = random.shuffle(pass_word)
new_pass = "".join(pass_word)
password = secrets.token_urlsafe(7)
return new_pass
message()
----------Próba!-------------
Határozzuk meg, hogy a jelszó nem lehet rövidebb mint 7 karakter!
Ki kell egészítenünk egy feltétellel a programunkat.
Létrehozunk egy újabb változót. c-t
Íme a kiegészítés:Ezzel módosíthatja a userGen () -t:
def userGen():
c = 0
upper = int(input("Hány kisbetű? "))
spec = int(input("Hány szimbólum? "))
num = int(input("Hány szám? "))
c += upper + num +spec
if c < 7:
print('A jelszó túl rövid!.')
userGen()
else:
return passGen(upper,spec,num)
A program módosítása:
import random
import string
import secrets
length = 7
# Egész számok
digits = "1234567890"
# Kisbetűk
letters = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"
# Szimbólumok
symbols = "!#$%&'()*+, -./:;<=>?@[\]^_`{|}~"
password = ''.join(secrets.choice(digits + letters + symbols) for t in range(20))
def message():
print("Helló ez egy jelszógenerátor. ")
print("Miből mennyi legyen?:")
passGen()
def passGen():
c = 0
upper = int(input("Hány kisbetűt? "))
spec = int(input("Hány szimbólum?? "))
num = int(input("Hány számot? "))
c += upper + num +spec
if c < length:
print('A jeszó túl rövid!.')
passGen()
else:
new_password = ""
for i in range(upper):
new_password += random.choice(letters)
for x in range(spec):
new_password += random.choice(symbols)
for y in range(num):
new_password += random.choice(digits)
pass_word = list(new_password)
shuff = random.shuffle(pass_word)
new_pass = "".join(pass_word)
password = secrets.token_urlsafe(7)
print(new_pass)
message()
----------------
Tovább finomíthatjuk meghatározhatjuk azt is hogy miből mennyit fogadjon el!
Gyakoroljuk az angol terminus technikust, és angolul írjuk a kísérő szöveget a programba.
import random
characters = {'digits': '1234567890',
'letters': 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ',
'symbols': "!#$%&'()*+,-./:;<=>?@[\]^_`{|}~"}
def getChoices(min_total=7):
print('Hello, here is a password generator: ')
print('Choose the length of your characters?')
while True:
total = 0
choices = {}
for category in characters.keys():
number = int(input(f'How many {category} do you want? '))
choices[f'num_{category}'] = number
total += number
if total >= min_total:
return choices
else:
print(f'Need at least {min_total} characters - please try again')
def passGen(choices):
new_password = ''
for category, options in characters.items():
for i in range(choices[f'num_{category}']):
new_password += random.choice(options)
pass_word = list(new_password)
random.shuffle(pass_word)
new_pass = ''.join(pass_word)
return new_pass
def main():
choices = getChoices()
print(f'Your choices: {choices}')
password = passGen(choices)
print(f'Your password: {password}')
main()
------------
Legyen a jelszó 12 karakter hosszú, de ha a felhasználónak hosszabb jelszóra van szüksége, akkor lehetővé kell tennie a felhasználó számára a jelszó hosszának beállítását. Így a következő módosítás végezzük el! Sőt a felhasználó több jelszót is generálhat egyszerre, ezt is lehetővé tesszük!
import random
characters = 'abcdefghijklmnopqrstuvwxyz0123456789!?@$%&'
password = ''
for c in range(12):
password += random.choice(characters)
print(password)
password_length = int(input('Enter password length: '))
password = ''
for c in range(password_length):
password += random.choice(characters)
print(password)
number_of_passwords = int(input('Hány kell még?: '))
password_length = int(input('Milyen hosszú legyen?: '))
for p in range(number_of_passwords):
password = ''
for c in range(password_length):
password += random.choice(characters)
print(password)
-------------------
Természetesen tudunk írni olyan programot is ami az ASCII kódtáblát felhasználva visszafejti a generált jelszót. Már csak egy lépésre vagyunk attól hogy variációkkal kísérletezzen a program!
További érdekes oldalak!
https://betterprogramming.pub/how-to-create-a-random-password-generator-in-python-9bf4d09dddc0
https://stackoverflow.com/questions/48449136/python-password-generator-that-creates-a-new-password-on-user-input/52735778
Egy érdekes videó
https://www.youtube.com/watch?v=f7TRhUoBaMM
Alapvető minta példák:
>>>
>>> random() # Random float: 0.0 <= x < 1.0
0.37444887175646646
>>> uniform(2.5, 10.0) # Random float: 2.5 <= x <= 10.0
3.1800146073117523
>>> expovariate(1 / 5) # Interval between arrivals averaging 5 seconds
5.148957571865031
>>> randrange(10) # Integer from 0 to 9 inclusive
7
>>> randrange(0, 101, 2) # Even integer from 0 to 100 inclusive
26
>>> choice(['win', 'lose', 'draw']) # Single random element from a sequence
'draw'
>>> deck = 'ace two three four'.split()
>>> shuffle(deck) # Shuffle a list
>>> deck
['four', 'two', 'ace', 'three']
>>> sample([10, 20, 30, 40, 50], k=4) # Four samples without replacement
[40, 10, 50, 30]
Kicsit komolyabban
Szimulációk:
>>>
>>> # Six roulette wheel spins (weighted sampling with replacement)
>>> choices(['red', 'black', 'green'], [18, 18, 2], k=6)
['red', 'green', 'black', 'black', 'red', 'black']
>>> # Deal 20 cards without replacement from a deck
>>> # of 52 playing cards, and determine the proportion of cards
>>> # with a ten-value: ten, jack, queen, or king.
>>> dealt = sample(['tens', 'low cards'], counts=[16, 36], k=20)
>>> dealt.count('tens') / 20
0.15
>>> # Estimate the probability of getting 5 or more heads from 7 spins
>>> # of a biased coin that settles on heads 60% of the time.
>>> def trial():
... return choices('HT', cum_weights=(0.60, 1.00), k=7).count('H') >= 5
...
>>> sum(trial() for i in range(10_000)) / 10_000
0.4169
>>> # Probability of the median of 5 samples being in middle two quartiles
>>> def trial():
... return 2_500 <= sorted(choices(range(10_000), k=5))[2] < 7_500
...
>>> sum(trial() for i in range(10_000)) / 10_000
0.7958
Nagyon komolyan
Példa statisztikai rendszerindításra újramintavételezéssel cserével a minta átlagának konfidencia intervallumának becsléséhez:
# http://statistics.about.com/od/Applications/a/Example-Of-Bootstrapping.htm
from statistics import fmean as mean
from random import choices
data = [41, 50, 29, 37, 81, 30, 73, 63, 20, 35, 68, 22, 60, 31, 95]
means = sorted(mean(choices(data, k=len(data))) for i in range(100))
print(f'The sample mean of {mean(data):.1f} has a 90% confidence '
f'interval from {means[5]:.1f} to {means[94]:.1f}')
Példa újramintavételezési permutációs tesztre a gyógyszer és a placebo hatása közötti megfigyelt különbség statisztikai szignifikanciájának vagy p-értékének meghatározásához:
# Example from "Statistics is Easy" by Dennis Shasha and Manda Wilson
from statistics import fmean as mean
from random import shuffle
drug = [54, 73, 53, 70, 73, 68, 52, 65, 65]
placebo = [54, 51, 58, 44, 55, 52, 42, 47, 58, 46]
observed_diff = mean(drug) - mean(placebo)
n = 10_000
count = 0
combined = drug + placebo
for i in range(n):
shuffle(combined)
new_diff = mean(combined[:len(drug)]) - mean(combined[len(drug):])
count += (new_diff >= observed_diff)
print(f'{n} label reshufflings produced only {count} instances with a difference')
print(f'at least as extreme as the observed difference of {observed_diff:.1f}.')
print(f'The one-sided p-value of {count / n:.4f} leads us to reject the null')
print(f'hypothesis that there is no difference between the drug and the placebo.')
Az érkezési idők és a kiszállítások szimulálása egy multiserver sorban:
from heapq import heappush, heappop
from random import expovariate, gauss
from statistics import mean, median, stdev
average_arrival_interval = 5.6
average_service_time = 15.0
stdev_service_time = 3.5
num_servers = 3
waits = []
arrival_time = 0.0
servers = [0.0] * num_servers # time when each server becomes available
for i in range(100_000):
arrival_time += expovariate(1.0 / average_arrival_interval)
next_server_available = heappop(servers)
wait = max(0.0, next_server_available - arrival_time)
waits.append(wait)
service_duration = gauss(average_service_time, stdev_service_time)
service_completed = arrival_time + wait + service_duration
heappush(servers, service_completed)
print(f'Mean wait: {mean(waits):.1f}. Stdev wait: {stdev(waits):.1f}.')
print(f'Median wait: {median(waits):.1f}. Max wait: {max(waits):.1f}.')
Receptek
Az alapértelmezett érték random()2⁻⁵³ többszöröseit adja vissza a 0,0 ≤ x <1,0 tartományban. Az összes ilyen szám egyenletesen helyezkedik el és pontosan reprezentálható, mint a Python lebeg. Sok más reprezentálható úszó ebben az intervallumban azonban nem lehetséges kiválasztás. Például 0.05954861408025609nem egész szám többszöröse 2⁻⁵3.
A következő recept más megközelítést alkalmaz. Az intervallumban található összes úszó lehetséges választás. A mantissa az egész számok egyenletes eloszlásából származik a 2⁵² ≤ mantissa <2⁵³ tartományban. A kitevő olyan geometriai eloszlásból származik, ahol az -53- nál kisebb kitevők fele olyan gyakran fordulnak elő, mint a következő nagyobb kitevők.
from random import Random
from math import ldexp
class FullRandom(Random):
def random(self):
mantissa = 0x10_0000_0000_0000 | self.getrandbits(52)
exponent = -53
x = 0
while not x:
x = self.getrandbits(32)
exponent += x.bit_length() - 32
return ldexp(mantissa, exponent)
Az osztály összes valós értékű disztribúciója az új módszert használja:
>>>
>>> fr = FullRandom()
>>> fr.random()
0.05954861408025609
>>> fr.expovariate(0.25)
8.87925541791544
A recept fogalmilag megegyezik egy olyan algoritmussal, amely a 2⁻1⁰⁷⁴ összes többszöröse közül a 0,0 ≤ x <1,0 tartományban választ. Az összes ilyen szám egyenletesen helyezkedik el, de a legtöbbet le kell kerekíteni a legközelebbi reprezentálható Python úszóra. (A 2⁻¹⁰⁷⁴ érték a legkisebb pozitív normalizálatlan úszó és egyenlő math.ulp(0.0).)
Valós értékű disztribúciók
A következő függvények konkrét reálértékű disztribúciókat generálnak. A függvényparamétereket az eloszlás egyenletében szereplő megfelelő változókról nevezik el, ahogyan a szokásos matematikai gyakorlatban használják; Ezen egyenletek többsége bármely statisztikai szövegben megtalálható.
random.random( )
Adja vissza a következő véletlenszerű lebegőpontos számot a tartományban [0.0, 1.0).
random.uniform( a , b )
Adjon meg egy véletlenszerű lebegőpontos N számot, amely a és a értékre vonatkozik.a <= N <= ba <= bb <= N <= ab < a
A végpont értéke baz egyenletben a lebegőpontos kerekítéstől függően szerepelhet a tartományban, vagy nem .a + (b-a) * random()
random.triangular( alacsony , magas , mód )
Adjon meg egy véletlenszerű N lebegőpontos számot úgy, hogy a határértékek között a megadott mód legyen. Az alacsony és a magas határérték alapértelmezés szerint nulla és egy. A mode argumentum alapértelmezés szerint a határok közötti középpont, szimmetrikus eloszlást adva.low <= N <= high
random.betavariate( alfa , béta )
Béta terjesztés. A paraméterekre vonatkozó feltételek és . A visszatérő értékek 0 és 1 között mozognak.alpha > 0beta > 0
random.expovariate( lambd )
Exponenciális eloszlás. lambd értéke 1,0 elosztva a kívánt átlaggal. Nem nullának kell lennie. (A paraméter neve „lambda” lenne, de ez egy fenntartott szó a Pythonban.) A visszaadott értékek 0-tól pozitív végtelenig terjednek, ha lambd pozitív, és negatív végtelenségtől 0-ig, ha lambd negatív.
random.gammavariate( alfa , béta )
Gamma eloszlás. ( Nem a gamma függvény!) A paraméterekre vonatkozó feltételek és .alpha > 0beta > 0
A valószínűségeloszlás függvénye:
x ** (alpha - 1) * math.exp(-x / beta)
pdf(x) = --------------------------------------
math.gamma(alpha) * beta ** alpha
random.gauss( mu , sigma )
Csak profiknak
Gauss-eloszlás. mu az átlag, és a sigma a szórás. Ez valamivel gyorsabb, mint az normalvariate()alább meghatározott funkció.
Többszálas megjegyzés: Ha két szál egyszerre hívja meg ezt a funkciót, akkor lehetséges, hogy ugyanazt a visszatérési értéket kapják. Ezt háromféleképpen lehet elkerülni. 1) Minden szál használja a véletlenszám-generátor egy másik példányát. 2) Helyezzen zárakat az összes hívás köré. 3) Használja helyette a lassabb, de szálkamentes normalvariate()funkciót.
random.lognormvariate( mu , sigma )
Log normál eloszlás. Ha ennek az eloszlásnak a természetes logaritmusát vesszük, normális eloszlást kapunk, átlagos mu-val és szórással . a mu értékének bármilyen értéke lehet, és a szigma nagyobbnak kell lennie, mint nulla.
random.normalvariate( mu , sigma )
Normális eloszlás. mu az átlag, és a sigma a szórás.
random.vonmisesvariate( mu , kappa )
MU az átlagos szög, radiánban 0 és 2 között * pi , és kappa az a koncentráció paraméter, amelynek nagyobbnak kell lennie, mint, vagy egyenlő nullával. Ha a kappa egyenlő nullával, ez az eloszlás egyenletes véletlenszerű szögre csökken a 0–2 * pi tartományban.
random.paretovariate( alfa )
Pareto terjesztés. az alfa az alakparaméter.
random.weibullvariate( alfa , béta )
Weibull eloszlás. az alfa a skála paraméter, a béta pedig az alak paraméter.
Funkciók egész számokra
random.randrange( stop )
random.randrange( indítás , leállítás [ , lépés ] )
Visszaad egy véletlenszerűen kiválasztott elemet innen . Ez egyenértékű , de valójában nem épít tartományi objektumot.range(start, stop, step)choice(range(start, stop, step))
A helyzeti argumentumminta megegyezik a range(). A kulcsszó argumentumokat nem szabad használni, mert a függvény váratlan módon felhasználhatja őket.
Megváltozott a 3.2-es verzióban:randrange() kifinomultabb az egyenletesen elosztott értékek előállításában. Korábban olyan stílust használt, int(random()*n)amely kissé egyenetlen eloszlásokat eredményezhet.
random.randint( a , b )
Adjon vissza egy véletlenszerű N számot úgy, hogy . Alias for .a <= N <= brandrange(a, b+1)
random.getrandbits( K )
Visszatér egy nem negatív Python egész szám k véletlenszerű bit. Ez a módszer a MersenneTwister generátorhoz tartozik, és néhány más generátor az API opcionális részeként is biztosíthatja. Ha elérhető, getrandbits()lehetővé teszi randrange()tetszőlegesen nagy tartományok kezelését.
Nincsenek megjegyzések:
Megjegyzés küldése