python學習 函數模塊,數據結構,字符串和列表

感謝駱昊大佬寫的學習文檔:學習文檔

例子1.尋找水仙花數。

說明:水仙花數也被稱爲超徹底數字不變數、自戀數、自冪數、阿姆斯特朗數,它是一個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)

例子2.正整數的反轉

num  = int(input('請輸入正整數'))
## 123456
rever_num = 0
while num >0:
    rever_num = rever_num*10 + num%10
    num //= 10
print(rever_num)

例子3:百錢百雞問題。

說明:百錢百雞是我國古代數學家張丘建在《算經》一書中提出的數學問題:
雞翁一值錢五,
雞母一值錢三,
雞雛三值錢一。
百錢買百雞,
問雞翁、雞母、雞雛各幾何?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只

例子4:斐波那契數列。輸出前20項。

a, b = 1, 1
# 經過遞推公式算出後面的18個數
for _ in range(18):
    a, b = b, a + b
    print(b, end=' ')

例子5:輸入M和N計算C(M,N)。

用循環作累乘來計算階乘數組

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!

as關鍵字

test.py

import module1 as m1
import module2 as m2

m1.foo()    # hello, world!
m2.foo()    # goodbye, world!

from...import...

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)

反斜槓和字符n

在字符串'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

is運算符

s1 = 'hello world'
s2 = 'hello world'
s3 = s2
# 比較字符串的內容
print(s1 == s2, s2 == s3)    # True True
# 比較字符串的內存地址
print(s1 is s2, s2 is s3)    # False True

成員運算 in和not in

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

若是想在一個字符串中查找有沒有另一個字符串,可使用字符串的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

逆向查找 rfind和rindex

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}')

strip 修剪操做

幫咱們得到將原字符串修剪掉左右兩端空格以後的字符串
還有:lstrip()和rstrip();

s1 = '   jackfrued@126.com '
# strip方法得到字符串修剪左右兩側空格以後的字符串
print(s1.strip())    # jackfrued@126.com

練習1:設計一個生成指定長度驗證碼的函數。

第一種方法:
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'))

練習3:在終端中顯示跑馬燈(滾動)文字。

說明:實現跑馬燈文字的原理很是簡單,
把當前字符串的第一個字符放到要輸出的內容的最後面,
把從第二個字符開始後面的內容放到要輸出的內容的最前面,
經過循環重複這個操做,就能夠看到滾動起來的文字。
兩次循環之間的間隔能夠經過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)

list函數將其餘序列變成列表

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]}次')

添加和刪除元素append,insert,remove,pop,clear,del

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']

元素位置和次數index,count

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

元素排序和反轉 sort,reverse

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中的列表底層是一個能夠動態擴容的數組,列表元素在內存中也是連續存儲的,因此能夠實現隨機訪問(經過一個有效的索引獲取到對應的元素且操做時間與列表元素個數無關)。咱們暫時不去觸碰這些底層存儲細節以及列表每一個方法的漸近時間複雜度(執行這個方法耗費的時間跟列表元素個數的關係),等須要的時候再告訴你們。現階段,你們只須要知道列表是容器,能夠保存各類類型的數據,能夠經過索引操做列表元素就能夠了。
相關文章
相關標籤/搜索