說明:水仙花數也被稱爲超徹底數字不變數、自戀數、自冪數、阿姆斯特朗數,它是一個3位數,該數字每一個位上數字的立方之和正好等於它自己.git
for i in range(100, 1000): a = i//100 b = i//10 % 10 c = i % 10 if i == a**3+b**3+c**3: print(i)
num = int(input('請輸入正整數')) ## 123456 rever_num = 0 while num >0: rever_num = rever_num*10 + num%10 num //= 10 print(rever_num)
說明:百錢百雞是我國古代數學家張丘建在《算經》一書中提出的數學問題:
雞翁一值錢五,
雞母一值錢三,
雞雛三值錢一。
百錢買百雞,
問雞翁、雞母、雞雛各幾何?api
for i in range(0,21): for j in range(0,34): z = 100 -5*i -3*j if 5*i + 3*j + z//3 ==100 and z % 3 ==0: print(f'公雞{i}只,母雞{j}只,小雞{z}只') 公雞2只,母雞30只,小雞0只 公雞5只,母雞25只,小雞0只 公雞8只,母雞20只,小雞0只 公雞11只,母雞15只,小雞0只 公雞14只,母雞10只,小雞0只 公雞17只,母雞5只,小雞0只 公雞20只,母雞0只,小雞0只
a, b = 1, 1 # 經過遞推公式算出後面的18個數 for _ in range(18): a, b = b, a + b print(b, end=' ')
用循環作累乘來計算階乘數組
m = int(input('m = ')) n = int(input('n = ')) # 計算m的階乘 fm = 1 for num in range(1, m + 1): fm *= num # 計算n的階乘 fn = 1 for num in range(1, n + 1): fn *= num # 計算m-n的階乘 fm_n = 1 for num in range(1, m - n + 1): fm_n *= num # 計算C(M,N)的值 print(fm//fn//fm_n)
def fac(num): fn = 1 for i in range(1,num+1): fn*=i return fn m = int(input('m = ')) n = int(input('n = ')) print(fac(m)//fac(n)//fac(m-n))
def add(a=0, b=0, c=0): return a + b + c print(add(1,2))
# 用星號表達式來表示args能夠接收0個或任意多個參數 def add(*args): total = 0 # 可變參數能夠放在for循環中取出每一個參數的值 for val in args: total += val return total print(add(1,2,3,4,5,6,7))
module1.py def foo(): print('hello, world!') module2.py def foo(): print('goodbye, world!') test.py import module1 import module2 # 用「模塊名.函數名」的方式(徹底限定名)調用函數, module1.foo() # hello, world! module2.foo() # goodbye, world!
test.py import module1 as m1 import module2 as m2 m1.foo() # hello, world! m2.foo() # goodbye, world!
from module1 import foo foo() # hello, world! from module2 import foo foo() # goodbye, world!
from module1 import foo as f1 from module2 import foo as f2 f1() # hello, world! f2() # goodbye, world!
函數是功能相對獨立且會重複使用的代碼的封裝
所謂字符串,就是由零個或多個字符組成的有限序列數據結構
s1 = 'hello, world!' s2 = "你好,世界!" print(s1, s2) # 以三個雙引號或單引號開頭的字符串能夠折行 s3 = ''' hello, world! ''' print(s3, end='')
提示:print函數中的end=''表示輸出後不換行,即將默認的結束符\n(換行符)更換爲''(空字符)。
# 頭尾帶單引號的hello, world! s1 = '\'hello, world!\'' print(s1) # 頭尾帶反斜槓的hello, world! s2 = '\\hello, world!\\' print(s2)
在字符串'hello\n'中,\n表示換行;而在r'hello\n'中,\n再也不表示換行,就是反斜槓和字符n。 # 字符串s1中\t是製表符,\n是換行符 s1 = '\time up \now' print(s1) # 字符串s2中沒有轉義字符,每一個字符都是原始含義 s2 = r'\time up \now' print(s2)
s1 = 'hello' + ' ' + 'world' print(s1) # hello world s2 = '!' * 3 print(s2) # !!! s1 += s2 # s1 = s1 + s2 print(s1) # hello world!!! s1 *= 2 # s1 = s1 * 2 print(s1) # hello world!!!hello world!!!
s1 = 'a whole new world' s2 = 'hello world' print(s1 == s2, s1 < s2) # False True print(s2 == 'hello world') # True print(s2 == 'Hello world') # False print(s2 != 'Hello world') # True s3 = '駱昊' print(ord('駱'), ord('昊')) # 39558 26122 s4 = '王大錘' print(ord('王'), ord('大'), ord('錘')) # 29579 22823 38180 print(s3 > s4, s3 <= s4) # True False
s1 = 'hello world' s2 = 'hello world' s3 = s2 # 比較字符串的內容 print(s1 == s2, s2 == s3) # True True # 比較字符串的內存地址 print(s1 is s2, s2 is s3) # False True
s1 = 'hello, world' print('wo' in s1) # True s2 = 'goodbye' print(s2 in s1) # False
s1 = 'hello, world' print(len(s1)) # 12 print(len('goodbye, world')) # 14
若是但願從字符串中取出某個字符,咱們能夠對字符串進行索引運算,運算符是[n],其中n是一個整數,假設字符串的長度爲N,那麼n能夠是從0到N-1的整數,其中0是字符串中第一個字符的索引,而N-1是字符串中最後一個字符的索引,一般稱之爲正向索引;在Python中,字符串的索引也能夠是從-1到-N的整數,其中-1是最後一個字符的索引,而-N則是第一個字符的索引,一般稱之爲負向索引。注意,由於字符串是不可變類型,因此不能經過索引運算修改字符串中的字符。 s1 = 'abc123456' N = len(s1) # 獲取第一個字符 print(s1[0], s1[-N]) # a a # 獲取最後一個字符 print(s1[N-1], s1[-1]) # 6 6 # 獲取索引爲2或-7的字符 print(s1[2], s1[-7]) # c c # 獲取索引爲5和-4的字符 print(s1[5], s1[-4]) # 3 3
s1 = 'abc123456' # i=2, j=5, k=1的正向切片操做 print(s1[2:5]) # c12 # i=-7, j=-4, k=1的正向切片操做 print(s1[-7:-4]) # c12 # i=2, j=9, k=1的正向切片操做 print(s1[2:]) # c123456 # i=-7, j=9, k=1的正向切片操做 print(s1[-7:]) # c123456 # i=2, j=9, k=2的正向切片操做 print(s1[2::2]) # c246 # i=-7, j=9, k=2的正向切片操做 print(s1[-7::2]) # c246 # i=0, j=9, k=2的正向切片操做 print(s1[::2]) # ac246 # i=1, j=-1, k=2的正向切片操做 print(s1[1:-1:2]) # b135 # i=7, j=1, k=-1的負向切片操做 print(s1[7:1:-1]) # 54321c # i=-2, j=-8, k=-1的負向切片操做 print(s1[-2:-8:-1]) # 54321c # i=7, j=-10, k=-1的負向切片操做 print(s1[7::-1]) # 54321cba # i=-1, j=1, k=-1的負向切片操做 print(s1[:1:-1]) # 654321c # i=0, j=9, k=1的正向切片 print(s1[:]) # abc123456 # i=0, j=9, k=2的正向切片 print(s1[::2]) # ac246 # i=-1, j=-10, k=-1的負向切片 print(s1[::-1]) # 654321cba # i=-1, j=-10, k=-2的負向切片 print(s1[::-2]) # 642ca
若是但願從字符串中取出每一個字符,可使用for循環對字符串進行遍歷,有兩種方式。 方式一: s1 = 'hello' for index in range(len(s1)): print(s1[index]) 方式二: s1 = 'hello' for ch in s1: print(ch)
s1 = 'hello, world!' # 使用capitalize方法得到字符串首字母大寫後的字符串 print(s1.capitalize()) # Hello, world! # 使用title方法得到字符串每一個單詞首字母大寫後的字符串 print(s1.title()) # Hello, World! # 使用upper方法得到字符串大寫後的字符串 print(s1.upper()) # HELLO, WORLD! s2 = 'GOODBYE' # 使用lower方法得到字符串小寫後的字符串 print(s2.lower()) # goodbye
若是想在一個字符串中查找有沒有另一個字符串,可使用字符串的find或index方法。 s1 = 'hello, world!' # find方法從字符串中查找另外一個字符串所在的位置 # 找到了返回字符串中另外一個字符串首字符的索引 print(s1.find('or')) # 8 # 找不到返回-1 print(s1.find('shit')) # -1 # index方法與find方法相似 # 找到了返回字符串中另外一個字符串首字符的索引 print(s1.index('or')) # 8 # 找不到引起異常 print(s1.index('shit')) # ValueError: substring not found
s = 'hello good world!' # 從前向後查找字符o出現的位置(至關於第一次出現) print(s.find('o')) # 4 # 從索引爲5的位置開始查找字符o出現的位置 print(s.find('o', 5)) # 7 # 從後向前查找字符o出現的位置(至關於最後一次出現) print(s.rfind('o')) # 12
能夠經過字符串的startswith、endswith來判斷字符串是否以某個字符串開頭和結尾;還能夠用is開頭的方法判斷字符串的特徵,這些方法都返回布爾值 s1 = 'hello, world!' # startwith方法檢查字符串是否以指定的字符串開頭返回布爾值 print(s1.startswith('He')) # False print(s1.startswith('hel')) # True # endswith方法檢查字符串是否以指定的字符串結尾返回布爾值 print(s1.endswith('!')) # True s2 = 'abc123456' # isdigit方法檢查字符串是否由數字構成返回布爾值 print(s2.isdigit()) # False # isalpha方法檢查字符串是否以字母構成返回布爾值 print(s2.isalpha()) # False # isalnum方法檢查字符串是否以數字和字母構成返回布爾值 print(s2.isalnum()) # True
s1 = 'hello, world' # center方法以寬度20將字符串居中並在兩側填充* print(s1.center(20, '*')) # ****hello, world**** # rjust方法以寬度20將字符串右對齊並在左側填充空格 print(s1.rjust(20)) # hello, world # ljust方法以寬度20將字符串左對齊並在右側填充~ print(s1.ljust(20, '~')) # hello, world~~~~~~~~
用print函數輸出字符串時,能夠用下面的方式對字符串進行格式化 1. a = 321 b = 123 print('%d * %d = %d' % (a, b, a * b)) 2. a = 321 b = 123 print('{0} * {1} = {2}'.format(a, b, a * b)) 3. a = 321 b = 123 print(f'{a} * {b} = {a * b}')
幫咱們得到將原字符串修剪掉左右兩端空格以後的字符串 還有:lstrip()和rstrip(); s1 = ' jackfrued@126.com ' # strip方法得到字符串修剪左右兩側空格以後的字符串 print(s1.strip()) # jackfrued@126.com
第一種方法: import random ALL_CHARS = '0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ' def generate_code(code_len=4): code = "" for i in range(code_len): index = random.randrange(0,len(ALL_CHARS)) code+=ALL_CHARS[index] return code print(generate_code(10)) 第二種方式: import random import string ALL_CHARS = string.digits + string.ascii_letters def generate_code(code_len=4): :param code_len: 驗證碼的長度(默認4個字符) :return: 由大小寫英文字母和數字構成的隨機驗證碼字符串 return ''.join(random.choices(ALL_CHARS, k=code_len)) print(generate_code(10)) 說明:random模塊的sample和choices函數均可以實現隨機抽樣, sample實現無放回抽樣,這意味着抽樣取出的字符是不重複的; choices實現有放回抽樣,這意味着可能會重複選中某些字符。 這兩個函數的第一個參數表明抽樣的整體,而參數k表明抽樣的數量。
第一種: def get_suffix(filename): 獲取文件名的後綴名 :param filename: 文件名 :return: 文件的後綴名 index = filename.rfind('.') return filename[index+1:] if index >0 else '' print(get_suffix('zhan.pdf')) 第二種: from os.path import splitext def get_suffix(filename): return splitext(filename)[1][1:] print(get_suffix('zhan.pdf'))
說明:實現跑馬燈文字的原理很是簡單, 把當前字符串的第一個字符放到要輸出的內容的最後面, 把從第二個字符開始後面的內容放到要輸出的內容的最前面, 經過循環重複這個操做,就能夠看到滾動起來的文字。 兩次循環之間的間隔能夠經過time模塊的sleep函數來實現, 而清除屏幕上以前的輸出可使用os模塊的system函數調用系統清屏命令來實現。 import os import time content = '北 京 歡 迎 你 爲 你 開 天 闢 地 ' while True: # Windows清除屏幕上的輸出 # os.system('cls') # macOS清除屏幕上的輸出 os.system('clear') print(content) # 休眠0.2秒(200毫秒) time.sleep(0.2) content = content[1:] + content[0]
將相對獨立且重複出現的功能封裝成函數
將一顆色子擲6000次,統計每一個點數出現的次數. import random f1 = 0 f2 = 0 f3 = 0 f4 = 0 f5 = 0 f6 = 0 for i in range(6000): face = random.randint(1, 6) if face==1: f1=f1+1 if face==2: f2=f2+1 if face==3: f3=f3+1 if face==4: f4=f4+1 if face==5: f5=f5+1 if face==6: f6=f6+1 print(f'1點出現了{f1}次') print(f'2點出現了{f2}次') print(f'3點出現了{f3}次') print(f'4點出現了{f4}次') print(f'5點出現了{f5}次') print(f'6點出現了{f6}次')
在Python中,列表是由一系元素按特定順序構成的數據序列,這樣就意味着定義一個列表類型的變量,能夠保存多個數據,並且容許有重複的數據。跟上一課咱們講到的字符串類型同樣,列表也是一種結構化的、非標量類型,操做一個列表類型的變量,除了可使用運算符還可使用它的方法。 items1 = [35, 12, 99, 68, 55, 87] print(items1) items2 = ['Python', 'Java', 'Go', 'Kotlin'] print(items2)
items1 = list(range(1, 10)) print(items1) # [1, 2, 3, 4, 5, 6, 7, 8, 9] items2 = list('hello') print(items2) # ['h', 'e', 'l', 'l', 'o'] 列表是一種可變數據類型,也就是說列表能夠添加元素、刪除元素、更新元素,這一點跟咱們上一課講到的字符串有着鮮明的差異。字符串是一種不可變數據類型,也就是說對字符串作拼接、重複、轉換大小寫、修剪空格等操做的時候會產生新的字符串,原來的字符串並無發生任何改變。
items1 = [35, 12, 99, 68, 55, 87] items2 = [45, 8, 29] # 列表的拼接 items3 = items1 + items2 print(items3) # [35, 12, 99, 68, 55, 87, 45, 8, 29] # 列表的重複 items4 = ['hello'] * 3 print(items4) # ['hello', 'hello', 'hello'] # 列表的成員運算 print(100 in items3) # False print('hello' in items4) # True # 獲取列表的長度(元素個數) size = len(items3) print(size) # 9 # 列表的索引 print(items3[0], items3[-size]) # 35 35 items3[-1] = 100 print(items3[size - 1], items3[-1]) # 100 100 # 列表的切片 print(items3[:5]) # [35, 12, 99, 68, 55] print(items3[4:]) # [55, 87, 45, 8, 100] print(items3[-5:-7:-1]) # [55, 68] print(items3[::-2]) # [100, 45, 55, 99, 35] # 列表的比較運算 items5 = [1, 2, 3, 4] items6 = list(range(1, 5)) # 兩個列表比較相等性比的是對應索引位置上的元素是否相等 print(items5 == items6) # True items7 = [3, 2, 1] # 兩個列表比較大小比的是對應索引位置上的元素的大小 print(items5 <= items7) # True
若是想逐個取出列表中的元素,可使用for循環的,有如下兩種作法。 方法一: items = ['Python', 'Java', 'Go', 'Kotlin'] for index in range(len(items)): print(items[index]) 方法二: items = ['Python', 'Java', 'Go', 'Kotlin'] for item in items: print(item)
import random counters = [0] * 6 for _ in range(6000): face = random.randint(1, 6) counters[face - 1] += 1 for face in range(1, 7): print(f'{face}點出現了{counters[face - 1]}次')
items = ['Python', 'Java', 'Go', 'Kotlin'] # 使用append方法在列表尾部添加元素 items.append('Swift') print(items) # ['Python', 'Java', 'Go', 'Kotlin', 'Swift'] # 使用insert方法在列表指定索引位置插入元素 items.insert(2, 'SQL') print(items) # ['Python', 'Java', 'SQL', 'Go', 'Kotlin', 'Swift'] # 刪除指定的元素 items.remove('Java') print(items) # ['Python', 'SQL', 'Go', 'Kotlin', 'Swift'] # 刪除指定索引位置的元素 items.pop(0) items.pop(len(items) - 1) print(items) # ['SQL', 'Go', 'Kotlin'] # 清空列表中的元素 items.clear() print(items) # [] items = ['Python', 'Java', 'Go', 'Kotlin'] del items[1] print(items) # ['Python', 'Go', 'Kotlin']
items = ['Python', 'Java', 'Java', 'Go', 'Kotlin', 'Python'] # 查找元素的索引位置 print(items.index('Python')) # 0 print(items.index('Python', 2)) # 5 # 注意:雖然列表中有'Java',可是從索引爲3這個位置開始後面是沒有'Java'的 print(items.index('Java', 3)) items = ['Python', 'Java', 'Java', 'Go', 'Kotlin', 'Python'] # 查找元素出現的次數 print(items.count('Python')) # 2 print(items.count('Go')) # 1 print(items.count('Swfit')) # 0
items = ['Python', 'Java', 'Go', 'Kotlin', 'Python'] # 排序 items.sort() print(items) # ['Go', 'Java', 'Kotlin', 'Python', 'Python'] # 反轉 items.reverse() print(items) # ['Python', 'Python', 'Kotlin', 'Java', 'Go']
# 建立一個由1到9的數字構成的列表 items1 = [] for x in range(1, 10): items1.append(x) print(items1) # 建立一個由'hello world'中除空格和元音字母外的字符構成的列表 items2 = [] for x in 'hello world': if x not in ' aeiou': items2.append(x) print(items2) # 建立一個由個兩個字符串中字符的笛卡爾積構成的列表 items3 = [] for x in 'ABC': for y in '12': items3.append(x + y) print(items3)
# 建立一個由1到9的數字構成的列表 強烈建議用生成式語法來建立列表 items1 = [x for x in range(1, 10)] print(items1) # [1, 2, 3, 4, 5, 6, 7, 8, 9] # 建立一個由'hello world'中除空格和元音字母外的字符構成的列表 items2 = [x for x in 'hello world' if x not in ' aeiou'] print(items2) # ['h', 'l', 'l', 'w', 'r', 'l', 'd'] # 建立一個由個兩個字符串中字符的笛卡爾積構成的列表 items3 = [x + y for x in 'ABC' for y in '12'] print(items3) # ['A1', 'A2', 'B1', 'B2', 'C1', 'C2']
scores = [[0] * 3] * 5 print(scores) # [[0, 0, 0], [0, 0, 0], [0, 0, 0], [0, 0, 0], [0, 0, 0]] # 嵌套的列表須要屢次索引操做才能獲取元素 scores[0][0] = 95 print(scores) # [[95, 0, 0], [95, 0, 0], [95, 0, 0], [95, 0, 0], [95, 0, 0]] scores = [[0] * 3 for _ in range(5)] scores[0][0] = 95 print(scores) # [[95, 0, 0], [0, 0, 0], [0, 0, 0], [0, 0, 0], [0, 0, 0]] Python中的列表底層是一個能夠動態擴容的數組,列表元素在內存中也是連續存儲的,因此能夠實現隨機訪問(經過一個有效的索引獲取到對應的元素且操做時間與列表元素個數無關)。咱們暫時不去觸碰這些底層存儲細節以及列表每一個方法的漸近時間複雜度(執行這個方法耗費的時間跟列表元素個數的關係),等須要的時候再告訴你們。現階段,你們只須要知道列表是容器,能夠保存各類類型的數據,能夠經過索引操做列表元素就能夠了。