Python簡介

我是一種跨平臺計算機程序設(shè)計語言
我是一種解釋性語言->開發(fā)過程中沒有編譯這個環(huán)節(jié),這一點我與java不一樣
我是一種交互式語言->你可以在我的提示符>>>直接執(zhí)行代碼
我是面對對象語言->在我的世界里一切皆對象
我是初學者最好的語言->對于初級程序員而言,我非常偉大的;

轉(zhuǎn)義字符

1. 就是反斜杠+想要實現(xiàn)轉(zhuǎn)義功能首字母. 當字符串中包含反斜杠,單引號和雙銀行等有特殊字符用途的字符是,必須使用反斜杠對這些字符進行轉(zhuǎn)義:
   1. 反斜杠\\
   2. 單引號'
   3. 雙引號"
2. 當字符串中包含換行回車,水平制表符或退格等無法直接表示的特殊字符時,也可以使用轉(zhuǎn)義字符當字符串:
   1. 換行\(zhòng)n
   2. 回的\r(return光標移動到本行的開頭,也就是前面的字符會消失)
   3. 水平制表符\t
   4. 退格\b(往前刪除一個字符)
   5. 空\0
   6. 換頁\f
   7. 八進制數(shù)\0dd如：\012標識換行
   8. 十六進制數(shù)\xhh：\x0a代表換行
      在字符串前面加R或者r標識，代表后面的字符串將無視轉(zhuǎn)義進行輸出

print('holle\nword')
print('holle  word')
print('holle\tword')
print('holle\bword')
print('holle\rword')

二進制與字符編碼

• 計算機為什么能夠認識我?
• 他只認識0和1根本不認識我,早期的程序員爸爸為了讓計算機能夠認識我將我能夠認識的符號和數(shù)字對應(yīng)好,然后做成一張表叫ASCLL表,告訴計算器某種符號你應(yīng)該是用那個整數(shù)表示:A使用了8個未知才能裝得下我,在計算機其他們叫一個字節(jié)
• 8bit->1byte
• 1024byte->1kb
• 1024kb->1mb
• 1024mb->1gb
• 1024gb->1Tb
  print(chr(0b1001111001011000))
  print(ord('乘'))
  結(jié)果
  鶻
  20056

數(shù)據(jù)類型

• 常用的數(shù)據(jù)類型:不可變的
  • 整數(shù)類型:int->98,英文為:integer 簡寫為int可以表示正數(shù),負數(shù)和零,整數(shù)的不同進制表示方式:
    • 十進制->默認的進制方式
    • 二進制->以0b開頭
    • 八進制->以0o開頭
    • 十六進制->0x開頭
  • 浮點數(shù)類型:float->2.112
  • 布爾類型:bool->True,False,用來表示真或假的值,True真,False假,布爾可以轉(zhuǎn)化為整數(shù)
    • True->1
    • False->0
      以下規(guī)則都是False

1. False或者None
2. 數(shù)值中的零，包括0，0.0虛數(shù)0
3. 空序列，包括字符串，空元組，空列表，空字典
4. 自定義對象的實例，該對象的bool方法返回False或者len返回0

• 字符串類型:str->'hello word',字符串被稱為不可變的字符序列
  • 可以使用單引號''雙引號""三引號"""或'''來定義
  • 單引號和雙引號的字符串必須在一行
  • 三引號定義的字符串可以分布在連續(xù)的多行

out = 'my name is  yanchenglong'
out2 = '''my name is 
yanchenglong'''
print (out)
print (out2)
#my name is  yanchenglong
# my name is
# yanchenglong

• 浮點類型
  • 浮點數(shù)整數(shù)部分和小數(shù)部分組成
  • 浮點數(shù)存儲不精準性
  • 使用浮點數(shù)進行計算時,可能會出現(xiàn)小數(shù)位數(shù)不確定的情況

print(1.1+2.2) #3.3000000000000003
# 解決方案 導入decimal
from decimal import Decimal
print(Decimal('1.1')+Decimal('2.2'))# 3.3

數(shù)據(jù)類型轉(zhuǎn)換

為什么需要數(shù)據(jù)類型轉(zhuǎn)換?-有效解決不同類型數(shù)據(jù)據(jù)拼接在一起處理的問題;

data = '1.2'
# print(int(data))# invalid literal for int() with base 10: '1.2'
data = '12'
print(int(data))
print(int(1.6))

Python保留字

python有一些單子賦予了特定的意義,這些代詞在你任何對想起名字的時候都不能用

['False', 'None', 'True', 'and', 'as', 'assert', 'async', 'await', 'break', 'class', 'continue', 'def', 'del', 'elif', 'else', 'except', 'finally', 'for', 'from', 'global', 'if', 'import', 'in', 'is', 'lambda', 'nonlocal', 'not', 'or', 'pass',
'raise', 'return', 'try', 'while', 'with', 'yield']

命名規(guī)則

1. 字母,數(shù)字,下劃線
2. 不能以數(shù)字開頭
3. 不能是保留字
4. 嚴格區(qū)分大小寫

import keyword
print(keyword.kwlist)

python中的注釋

注釋,在代碼對代碼的功能進行解釋說明的標注性文字,可以提高代碼的可讀性
注釋的內(nèi)容會被python解釋器忽略
通過包括三種類型的注釋
單行注釋-> 以# 開頭知道換行結(jié)束
多行注釋->并沒有單獨的多行注釋,將一個對三引號之間的代碼成為多行注釋
中文編碼聲明注釋-> 在文件開頭加上中文生命注解,用指定源碼文件編碼格式-> # coding:gbk

Python的輸入函數(shù)

輸入函數(shù)基本使用
present=input('大圣想要什么禮物呢?')
作用:接受來自用戶的輸入
返回值類型: 輸入值的類型為str
值的存儲:使用=對輸入的值進行存儲

value = input('請輸入第一個數(shù)值')
value2 = input ('請輸入第二個數(shù)值')
print(type(value))
print(int(value)+int(value2))

輸出函數(shù)

1. 可以輸出數(shù)字,浮點如print(123)
2. 可以輸出字符串print('123')
3. 可以輸出含有運算符的表達式如print(1+2)

其中#號是注釋

輸出位置

1. 顯示器print(1)
2. 文件

   # 參數(shù)一,文件地址.參數(shù)二:文件的創(chuàng)建,已讀寫的方式打開文件,如果文件不存在則進行創(chuàng)建,如果存在則接著后面追加,print 在打印時使用file=文件對象
    holle = open(r'C:\Users\sj176\Desktop\holleWord.txt', 'a+')
    print('holleWord', file=holle)
    holle.close()
   
   

輸出形式

1. 換行
2. 不換行

python 中的運算符

1. 算數(shù)運算符:加減乘除+-/ 取整// 取余% 幕運算*
2. 賦值運算符: 執(zhí)行順序:右->左
   1. 支持鏈式賦值:a=b=c=10
   2. 支持參數(shù)復(fù)制:+=,-=,/=,//=,%=
   3. 支持系列解包復(fù)制:a,b,c=10,20,30
3. 比較運算符:比較值的結(jié)果是bool類型,對表達式的結(jié)果進行大小真假等比較:>,<,==,>=,<=,!=
   1. 對象比較==
   2. 對象的id比較:is ,is not
4. 布爾運算符:
   1. and 當兩個運算結(jié)果true時運算結(jié)果才會true
   2. or 只有一個運算符為true時結(jié)果才會true
   3. not 如果運算符為true 返回結(jié)果為false,如果運算符為false結(jié)果為true
   4. in 在不在這個當中
   5. not in 不在這里當中
5. 位運算符:運算二進制的數(shù)據(jù)
   1. 位與& ->對應(yīng)位數(shù)都是1,結(jié)果位數(shù)才是1,否則為0
   2. 位或| ->對應(yīng)位數(shù)都是0,結(jié)果位數(shù)才是0否則為1
   3. 左移位運算符->相當于*2,高位溢出舍去,低位補0
   4. 右移位運算符->相當于/2,低位溢出舍去,高位補0

運算符的優(yōu)先級

**
*,/,//,%
+,-
<<<,>>>
&
|
>,<,>=,<=,==,!=
and
or
=


""" 一個= 稱為賦值運算符,==稱為比較運算符
一個變量由三部分組成:id name value  使用id()函數(shù)可以看到該變量的id
==比較的就是value
is,not is比較的時id
"""
a,b=10,10
list1=[1,2,3]
list2=[1,2,3]
print(a==b)
print(a is b)
print(list1==list2)
print(list1 is list2)
# True
# True
# True
# False

對象的布爾值

python一切皆對象,所有對象都有一個bool值,獲取對象的布爾值bool()函數(shù)即可
以下對象的布爾值為False

1. False
2. 數(shù)值0
3. None
4. 空字符串
5. 空列表
6. 空元組
7. 空字典
8. 空集合
   除了這些剩下的都是True

分支語句

分支語句

score=int(input('pass input int score'))
if 90<=score<=100:
    print('a')
elif 80<=score<=89:
    print('b')
elif 70<=score<=79:
    print('c')
elif 60<=score<=69:
    print('d')
elif 0<=score<=59:
    print('e')
else :
    print('sorry you score error')

條件表達式

num_a = int(input('pass input number_a int'))
num_b = int(input('pass input number_b int'))
# if num_a >= num_b:
#     print(num_a, '>=', num_b)
# else:
#     print(num_a, '<', num_b)
# 如果為True執(zhí)行左邊的如果為False執(zhí)行右邊的
print(str(num_a)+'>='+str(num_b) if num_a > num_b else str(num_a)+'<'+str(num_b))

pass 語句

語句什么都不做,只是一個占位符,用在語法上需要語句的地方

vip = input('is you vip')
if vip == 'y':
    print('1123')
else:
    pass

range函數(shù)

range()函數(shù),用于生成一個整數(shù)序列,創(chuàng)建rage對象的三種方式

r = range(10)
# print(r) print:range(0, 10)
print(list(r))

r = range(2, 10)
# print(r) print:range(0, 10)
print(list(r))

r = range(1, 10, 2)
# print(r) print:range(0, 10)
print(list(r))
# print---
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
[2, 3, 4, 5, 6, 7, 8, 9]
[1, 3, 5, 7, 9]

• 返回值是一個迭代對象
• range類型的有點?:不管range對象表示的整數(shù)序列有多長,所有range對象占用的內(nèi)存空間都是相同的,應(yīng)為僅僅需要存儲start stop和step,只有當用到range對象是,才會去計算序列中的相關(guān)元素
• in與not in 判斷整數(shù)序列中是否存在(不存在)指定的整數(shù)

循環(huán)結(jié)構(gòu)

• 反復(fù)做同一件事的情況,稱為循環(huán)
• 循環(huán)的分類
  • while
  • for -in
• 語法結(jié)構(gòu)

while 條件表達式
    條件執(zhí)行體(循環(huán)體)

選擇結(jié)構(gòu)的if與循環(huán)結(jié)構(gòu)while的區(qū)別

• if是判斷一次,條件為True執(zhí)行一行
• while是判斷N+1次,條件為True執(zhí)行N次

四部循環(huán)發(fā)

1. 初始化變量
2. 條件判斷
3. 條件執(zhí)行體
4. 改變變量

while循環(huán)的執(zhí)行流程

a = 1
i = 0
while a <= 90:
print('a<10', a)
if not bool(a % 2):
i += a
a += 1
print('sum', i)

for-in循環(huán)

• in表達從(字符串,序列等)中依次取值,又稱為遍歷
• for-in遍歷的對象必須是可迭代對象

for-in的語法結(jié)構(gòu)
for 自定義的變量 in 可迭代對象:
循環(huán)體

for item in 'python':
    print(item)
    pass
# p
# y
# t
# h
# o
# n
for item in range(10):
  print(item)
  pass

# 0
# 1
# 2
# 3
# 4
# 5
# 6
# 7
# 8
# 9
for _ in range(10):
  print('hello word')
  pass

# 使用for循環(huán),計算1到100之間的偶數(shù)和
sum = 0
for item in range(1,101):
  if item % 2 == 0:
    sum += item
    pass
  pass
print(sum)

# 得到100-1000的水仙花數(shù)
for item in range(100,1000):
  ge=item%10 #得到個位數(shù)
  shi=item//10%10# 的帶十位數(shù)
  bai=item//100 #得到百位數(shù)
  print(ge,shi,bai)
  if ge**3+shi**3+bai**3==item:
    print(item)

循環(huán)體內(nèi)不需要訪問自定義變量,可以將自定義變量代替為下劃線

流程控制語句

break語句,用于結(jié)束循環(huán)結(jié)構(gòu),通常與分支語句if一起使用

for item in range(3):
    pwd = input('input')
    if pwd == '1111':
        print('yes')
        break
    else:
        print('no')
        pass
    pass

a = 0
while a < 3:
    pwd = input('input: ')
    if pwd == '4444':
        print('yes')
        break
    else:
        print('no')
        pass
    a += 1
    pass

continue語句

用戶結(jié)束當前循環(huán),進入下一次循環(huán),通常用于分支語句中的if一起使用

for item in range(1, 51):
    if item % 5 != 0:
        continue
    else:
        print(item)
        pass
    pass

else語句

與else語句配合使用的三種情況

if...else
while...else
for...else

test

for item in range(3):
    pwd = input('input')
    if pwd == '1111':
        print('yes')
        break
    else:
        print('no')
        pass
else:
    print('sorry 3 password error')


a = 0
while a < 3:
  a += 1
  pwd = input('input')
  if pwd == '1111':
    print('password yes')
    break
  else:
    print('password no')

else:
  print('3 error')
  pass

嵌套循環(huán)
循環(huán)結(jié)構(gòu)中又嵌套了另外的完整循環(huán)結(jié)構(gòu),其中內(nèi)存循環(huán)作為外城循環(huán)的循環(huán)體執(zhí)行
99乘法表

for item in range(1, 10):
    for j in range(1, item+1):
        print(str(item)+'*'+str(j)+'='+str(item*j), end='\t')
    print()
    pass

二重循環(huán)中的break和continue

for i in range(5):
    for j in range(1, 11):
        if j % 2 == 0:
            # break
            continue
        print(j, end='\t')
        pass
    print()
    pass

列表

1. 變量可以存儲一個元素,而列表是一個'大容器'可以存儲N多個元素,程序可以方便地對這些數(shù)據(jù)進行整體操作
2. 列表相當于其他語言中的數(shù)組

lst = [1, '23', 1.1]
列表需要使用中括號[]元素之間使用英文的都好進行分隔

列表的創(chuàng)建方式
使用中括號
調(diào)用內(nèi)置函數(shù)list()

ls=list([1,2,'12'])
print(ls)

ls=[1,2,'12']
print(ls)

列表特點

1. 列表元素按順序有序排序
2. 索引映射唯一數(shù)據(jù)
3. 列表可以存儲重復(fù)數(shù)據(jù)
4. 任意數(shù)據(jù)類型混存
5. 根據(jù)需要動態(tài)分配和回收內(nèi)存

列表的查詢操作

1. 獲取列表的索引:如果列表中存在N個相同元素,只返回相同元素中的第一個元素的索引
2. 如果查詢的元素列表中不存在,則會拋出ValueError
3. 還可以指定的start和stop之間進行查找

獲取列表中的單個元素

1. 正向索引0到N-1
2. 逆向索引從-N到-1
3. 指定索引不存在,拋出IndexError

獲取列表中的多個元素
列表名[start:stop:step]

1. 切片的結(jié)果->源列表片段的拷貝
2. 切片的范圍->[start,stop]
3. step默認為1->簡寫為[start,stop]
4. step為正數(shù)->[:stop:step]切片的抵押給元素默認是列表的第一個元素-從start開始往后計算切片,[start::step] 切片到最后一個元素,默認是列表的最后一個元素,-從start開始往后計算切片
5. step為負數(shù):[:stop:step]->切換的第一個元素默認是列表的最后一個元素,從start開始計算切片,[start::step]切片的最后一個元素默認是列表第一個元素,從start開始計算切片

lst=[10,20,30,40,50,60,70,80,90,100]
lst2=lst[1:6:1]
print(id(lst))
print(id(lst2))
print(lst[1:6:])
print(lst[1:6:2])
print(lst[:6:2])
print(lst[1::2])
print(lst[::-1])
print(lst[6::-1])
print(lst[6:0:-2])

列表元素的查詢操作

• 判斷指定元素在列表中是否存在
  元素 in 列表名,元素 not in 列表名
• 列表元素的便利
  for 迭代變量 in 列表名:
  操作

  msg = 'holle word'
lst = [1,2,3,4,5,6]
print('1' in lst)
for item in lst:
  print(item)

列表元素的增刪改操作

1. 增加操作:
   1. append()在末尾增加一個元素;
   2. extend()在列表末尾至少添加多個元素;
   3. insert()在任意位置插入元素,參數(shù)1寫index參數(shù)2寫想要添加的元素,
   4. 切片:在列表的任意位置添加至少一個元素

lst=[1,2,3,4,5]
lst.append([1,2,3,4])
print(lst)
lst.extend([1,2,3,4])
print(lst)
lst3=[True,False]
lst[3:]= lst3
print(lst)

2. 列表元素刪除的操作
   1. remove()一次刪除一個元素,重復(fù)元素只刪除第一個,元素不存在拋出valueError
   2. pop()刪除一個指定索引位置上的元素,指定索引不存在拋出IndexError,不指定索引,刪除列表中最后一個元素
   3. 切片:產(chǎn)生新的對象, 或者在改對象上進行切片賦值
   4. clear()清空列表
   5. del 刪除列表對象

lst=[1,2,3,4,5,2]
lst.pop(1)
print(lst)
# lst.pop(8)
lst.pop()
print(lst)

newlist=lst[1:2]
print(newlist)
# 不產(chǎn)生新的對象,執(zhí)行切片刪除
lst[1:3]=[]
print(lst)
# 清除列表中所有元素
lst.clear()
# del lst 將對象刪除
del lst
print(lst)

刪除某一個值
del lst[1]

列表修改操作

1. 修改一個值:使用賦值
2. 修改多個值:使用切片

lst=[1,2,3,4,5,2]
lst[2]=100 # 修改一個值
print(lst)
lst[1:3]=[300,500,1000,1,2] # 修改多個值
print(lst)

列表元素的排序

1. sort()方法在原對象進行修改
2. sorted()內(nèi)置方法,會產(chǎn)生一個新對象,reverse=True指定是否是倒敘;

lst=[1,2,3,4,5,2]
print('排序前的列表',lst,id(lst))
lst.sort()
print('排序后的列表',lst,id(lst))

# 指定參數(shù)后,可以將列表倒敘排序reverse=True,reverse=False就是升序排序
lst.sort(reverse=True)
print(lst)
print('----------------')
# 使用內(nèi)置sorted()
lst=[1,2,3,4,5,2]
newLst=sorted(lst,reverse=True)
print(newLst,id(newLst))
print(lst,id(lst))

其中還有：sort（key=str.lower,reverse=True)排序時不區(qū)分大小寫
列表生成式
語法格式[ii for i in range(10)]
ii表示列表元素的表達式,i 自定義變量 range(10)可迭代對象

字典

python內(nèi)置的數(shù)據(jù)結(jié)構(gòu)之一,與列表一樣是一個可變序列
以鍵值對的存儲數(shù)據(jù),字典是一個無序的序列
字典的實現(xiàn)原理與查字典類似,查字典是先根據(jù)部首或拼音查找對應(yīng)的頁面,Python中的字典是根據(jù)key查找value所在位置;

1. 字典的創(chuàng)建
   1. 使用花括號{}{'張三':100,'王五':10}
   2. 內(nèi)置函數(shù)dict()dict(zhangsna=100,雷轟=11)
2. 從字典中獲取數(shù)據(jù)
   1. []取值
   2. get()取值

data={'張三':100,'王五':10}
ww=data['王五']#如果獲取不到則會報錯KyeError
print(ww)
print(data.get('張三'))# 如果不存在則會None
print(data.get('張1',88))# 如果不存在則展示88設(shè)置的默認值

還可以這樣：

price = [12000, 30, 220000, 10000, 8888]
sale=[x for x in price if x>=5000]
print(price)
print(sale)

二維列表

arr=[]
for i in range(4):
    arr.append([])
    for j in range(5):
        arr[i].append(j)

print(arr)

輸出

[[0, 1, 2, 3, 4], [0, 1, 2, 3, 4], [0, 1, 2, 3, 4], [0, 1, 2, 3, 4]]

上述列表可以使用推導式來完成：arr=[[j for j in range(5)] for i in range(4)]

3. 字典的常用操作

data={'張三':100,'王五':10}
print('wangwu' in data)
print('wangwu' not in data)
del data['王五']#刪除王五字段,如果是data則會刪除data字典,如果是字典里面的內(nèi)容則會刪除指定的內(nèi)容
data.clear()#將字典所有元素清空
print(data)
#新增
data['djij']=1000
print(data)
#修改
data['djij']=10
print(data)

4. 字典視圖
   1. keys獲取所有key
   2. values獲取所有value
   3. item獲取所有的key和value的鍵值對

data={'張三':100,'王五':10}
keyss=data.keys()
print(keyss,type(keyss))
print(list(keyss))#將所有的keys轉(zhuǎn)換成列表
values=data.values()
print(values,type(values))
print(list(values))
# 獲取所有的鍵值對
items=data.items()
print(items,type(items))
print(list(items))#是由元組組成的

5. 遍歷字典

data={'張三':100,'王五':10}
for item in data:
    print(item)
    print(data[item])

5. 字典生成式

items=['a','B','C','D','E','F','G']
pr=[10,20,30,5,1,2]
d={item.upper():pr  for item,pr in zip(items,pr)}
print(d) #將key轉(zhuǎn)換成大寫upper(),如果key和value的長度不一致則會取最短的進行復(fù)制壓縮

6. 字典的特點
   1. key不允許重復(fù),value可以重復(fù)
   2. 字典中的元素是無序的
   3. 字典中的key必須是不可變對象
   4. 字典也是可以根據(jù)需要動態(tài)的伸縮
   5. 字典會浪費較大的內(nèi)存空間,是一種空間換時間的數(shù)據(jù)結(jié)構(gòu)

元組

Python內(nèi)置的數(shù)據(jù)結(jié)果之一,是一個不可變序列
不可變序列與可變序列

1. 不可變序列:字符串,元組
   1. 不可變序列:沒有增三改的操作
2. 可變序列:列表,字典
   1. 可變序列:可以對序列執(zhí)行增刪改操作,對象地址不發(fā)生更改
3. 為什么要將元組設(shè)計成不可變序列?
   1. 在多任務(wù)環(huán)境下,同時操作對象是不需要加鎖
   2. 因此,在程序中盡量使用不可變序列
   3. 注意事項:
      1. 元組中存儲的時對象引用,如果元組中對象本身不可變對象,則不能再引用其他其他對象
      2. 如果元組中的對象時可變對象,則可變對象的引用不允許改變,但數(shù)據(jù)可以改變

s='shoee'
print(id(s)) #2090536342704
s+='ddd'
print(id(s)) #2090536344752

1. 元組的創(chuàng)建方式
   1. t=('1','2')
   2. tuple(())

t=(1,2,'3') # 這個括號可以省略不寫(),如果元組只有一個 元素時,需要在后面加上,號
print(t,type(t))
dd=tuple((1,2,3,'4'))
print(dd)
t='2',
print(t)
# 空的創(chuàng)建
lst=[]
lst1=lst()

d={}
d1=dict()

t=()
t=tuple()

2. 元組遍歷

t=(1,2,3,4,5,6,'1')
print(t[1])
print(len(t)) # len獲取元組列表等長度的內(nèi)置函數(shù)
for item in t:
    print(item)

集合

python語言提供的內(nèi)置數(shù)據(jù)結(jié)構(gòu)
與列表,字典都一樣屬于可變類型的序列
集合沒有value的字典

1. 集合的創(chuàng)建方式
   1. 直接使用{}
   2. 內(nèi)置函數(shù)set

s={'1',2,3,4,5,'2','1'}
print(s)# 不允許重復(fù)
s1=set(range(6))
print(s1,type(s1))
s3=set((1,2,3,4,1,65))
print(s3,type(s3))
s4=set('python')
print(s4,type(s4))
s5=set({12,4,12,'1'})
print(s5,type(s5))
s6=set({1,2,3,4,1,2,3})
print(s6,type(s6))
s7={}
s8=set()
print(s7,type(s7))
print(s8,type(s8))

2. 集合元素的判斷操作
   1. in 或not in
3. 集合元素的新增操作
   1. 調(diào)用add()方法,一次添加一個元素
   2. 調(diào)用update()方法至少添加一個元
4. 集合元素的刪除操作
   1. 調(diào)用remove()方法,一次刪除一個指定的元素,如果指定的元素不存在拋出KyeERRPR錯誤
   2. discard()方法,一次刪除一個指定元素,如果指定的元素不存在不拋出異常
   3. 調(diào)用pop方法,一次刪除要給任意元素
   4. clear()方法,清空集合
5. 集合之間的關(guān)系
   1. 兩個集合是否相等,可以用運算符==或!=進行判斷
   2. 一個結(jié)合是否是另一個集合的子集
      1. 可以調(diào)用方法issubset進行判斷
      2. B是A的子集
   3. 一個集合是否是兩一個集合的超集,父級
      1. 可以調(diào)用方法issuperset進項判斷
      2. a是b的超集
   4. 兩個集合是否沒有交集
      1. 可以調(diào)用方法isdisjoint進行判斷
6. 集合的數(shù)學操作
   1. 交集
   2. 并集
   3. 差集
   4. 對稱差集

s1={10,20,30,40,50,60}
s2={10,20,30,40,1}
# 交集
print(s1.intersection(s2))
print(s1 & s2)
# 并集操作
print(s1.union(s2))
print(s1 | s2)
# 差集操作
print(s1.difference(s2))
print(s1-s2)
# 對稱差值
print(s1.symmetric_difference(s2))
print(s1 ^ s2)

7. 集合生成式
   1. {i*i for i in range(1,100)}
   2. 將{}修改為[]就是列表生成式
   3. 元組沒有生成式

lst={i*i for i in range(1,7)}
print(lst)

字符串常用操作

1. 字符串的駐留機制
   1. 在python中字符串是基本數(shù)據(jù)類型,是一個不可變字符序列
   2. 進保存一份相同且不變字符串的方法,不同的值被存放在字符串的駐留池中,python的駐留機制對相同的字符串只保留一份拷貝,后續(xù)創(chuàng)建相同字符串時,不會開辟新的控件,而是把字符串的地址賦給新創(chuàng)建的變量
   3. 駐留機制的幾種清空
      1. 字符串長度為0或者1時
      2. 符合標識符的字符串如abc%
      3. 字符串只在編譯時駐留,而非運行時
      4. [-5,256]整數(shù)也是駐留的
   4. sys中intern方法輕質(zhì)2個字符執(zhí)行同一個對象
   5. PyCharm對字符串進行了優(yōu)化處理
   6. 字符串駐留機制的優(yōu)缺點
      1. 當需要值相同的字符串時,可以直接從字符串池中拿來使用,避免頻繁的創(chuàng)建和銷毀,提聲效率和節(jié)約內(nèi)存,因此字符串拼接和修改字符串時比較影響性能的.
      2. 在需要進行字符串拼接時建議使用str類型的join方法,而非+因為join()方法是先計算出所有字符產(chǎn)的長度,然后再拷貝,只new一次對象,效率要比+效率高
2. 字符串的常用操作
   1. index():查找字符串substr第一次出現(xiàn)的位置,如果查找的字符串不存在時,拋出ValueError
   2. reindex():查找substr最后一次出現(xiàn)的位置如果查找不到則會拋出ValueRError
   3. find()查找字符串substr第一次出現(xiàn)的位置,如果查找不到則會返回-1
   4. rfind()查找字符串substr最后一次出現(xiàn)的位置,如果查找不到則會返回-1
   5. upper()把字符串所有字符都轉(zhuǎn)換成大寫字母,注意轉(zhuǎn)換之后會產(chǎn)生一個新對象,不管內(nèi)容是否一致
   6. lower(),把字符串中所有字符都轉(zhuǎn)換成小寫
   7. swapcase()把字符串中所有大寫字母轉(zhuǎn)換成小寫,把小寫字母都轉(zhuǎn)換成大寫字母
   8. capitlize()把第一個字符轉(zhuǎn)換成大寫,把其余字符轉(zhuǎn)換成小寫
   9. title()把每個單詞的第一個字符轉(zhuǎn)換成大寫,把每隔單詞的剩余找媳婦轉(zhuǎn)換成小寫
   10. center()劇中對其,第一個參數(shù)指定寬度,第二個參數(shù)指定填充符,第二個參數(shù)是可選的,默認是空格,如果設(shè)置寬度小于實際的寬度則返回原字符串.
   11. ljust()左對齊,第一個參數(shù),蝶兒個參數(shù)指定填充字符,第二個參數(shù)是可選的,默認是空格如果設(shè)置寬度小于實際寬度則返回原字符串
   12. rjust()右對齊,第一個參數(shù)指定高度,第二個參數(shù)指定填充符,第二個參數(shù)是可選的,默認是空格如果設(shè)置寬度小于實際寬度,則返回原字符串
   13. zfill()右對齊,左邊用0填充,該方法只接受一個參數(shù),用于指定字符串的寬度,如果指定的寬度小于等于字符串長度,返回字符串本身 -0001234會添加到-號后面
   14. split()從字符串的左邊開始劈分,默認的劈分字符串空格字符串,返回值是一個列表,通過參數(shù)sep=指定劈分字符串是劈分符號,通過參數(shù)maxsplist=指定劈分字符串時最大劈分次數(shù),在經(jīng)過最大劈分之后,剩余的字符串會單獨作為一部分
   15. rsplist()從字符串最右邊開始劈分,默認的劈分字符串時空格字符串,返回值都是一個列表,通過sep指定劈分字符串的劈分符,通過參數(shù)maxsplit指定劈分字符串的最大劈分次數(shù),在經(jīng)過最大劈分之后,剩余的字符串單獨作為一部分
   16. isidentifier()判斷字符串是不是合法的標識符
   17. isspace()判斷指定的字符串是否全部由空白字符組成(回車,換行,水平制表符)
   18. isalpha()判斷指定的字符串是否全部有字母組成
   19. isdecimal()判斷指定字符串是否全部由十進制的數(shù)字組成
   20. isnumeric()判斷指定字符串是否全部由數(shù)字組成,羅馬漢字的4都會是True
   21. isalnum()判斷字符串是否全部由字母和數(shù)字組成和漢字
   22. join()將列表或元組的字符串合并成一個字符串,或者更改連接符號
   23. replace()第一個參數(shù)指定被替換的字符串,第二個參數(shù)指定替換字符串的字符串,該方法返回替換后得到新的字符串,替換前的字符串不發(fā)生變化,調(diào)用該方法時可以通過第三個參數(shù)指定最大替換數(shù)
   24. 字符串的比較操作>,>=,=,<,<=,==,!=
       1. 比較規(guī)則:首先比較兩個字符串中的第一個字符,如果相等則繼續(xù)比較下一個字符,一次比較下去,知道兩個字符串中的字符不相等時,其比較結(jié)果就是兩個字符串的比較結(jié)果,兩個字符串中的所有后續(xù)字符將不再被比較
       2. 比較原理:兩個字符串進行比較是,比較的是其ordinal value 原始值,調(diào)用內(nèi)置函數(shù)ord可以得到指定字符的ordinal value.與內(nèi)置函數(shù)ord對應(yīng)的是內(nèi)置函數(shù)chr調(diào)用內(nèi)置函數(shù)chr時指定ordinal value可以得到其對應(yīng)的字符

       3. == 與 is的區(qū)別,==比較的時value,is比較的時id

   25. 25.字符串的切片操作,字符串是不可變類型,不具備增刪改等操作,切片操作將產(chǎn)生新的對象
   26. 格式化字符串%占位符,%s字符串,%i整數(shù)%f浮點數(shù)
   27. 字符串的編碼轉(zhuǎn)換,為什么需要編碼轉(zhuǎn)換?,因為傳輸時是byte字節(jié)傳輸?shù)?所以需要進行編碼解碼
       1. 將字符轉(zhuǎn)換成二進制數(shù)據(jù)bytes
       2. 將bytes類型的數(shù)據(jù)轉(zhuǎn)換成字符串類型

lst=['hello','java','python']
print('|'.join(lst))
t=('hello','java','python')
print('.'.join(t))
st='hello,java,python'
print('/'.join(st))

s='hello,Python'
s1=s[:5]
s2=s[6:]
print(s1,s2)
s3='!'
newstr=s1+s3+s2
print(s[::-1])# 默認從字符串的最后一個元素開始,到字符串的第一個元素結(jié)束,因為步長為負數(shù),所以是倒著的
print(s[-6::1])# 從索引為-6開始,到字符串的u子最后一個元素結(jié)束,步長為1

name='yanchenglong'
age=20
sorre=60.7
print('我叫%s,今年%d歲,我考了%f分數(shù)'%(name,age,sorre))
print('我叫{0},今年{1}歲,我考了{2}分數(shù)'.format(name,age,sorre))
print(f'我叫{name},今年{age}歲,我考了{sorre}分數(shù)')
#指定寬度
print('%10d'%99)
print('%f'% 3.1415926)
print('%.3f'%3.1415926)
#同時表示寬度和精度
print('%10.3f'%32.1415926)
print('{0:.3f}'.format(3.1415926)) #.3f標識是3位小數(shù)
print('{0:10.3f}'.format(3.1415926))
name='yanchenglong,我的天'
print(name.encode(encoding='GBK')) # 在GBK中這種編碼格式中,一個中文字符占兩個字節(jié)
print(name.encode(encoding='UTF-8'))# 在UTF-8這種百編碼格式中一個中文占三個字節(jié)
# 解碼
byte=name.encode(encoding='UTF-8')
print(byte.decode(encoding='UTF-8'))

函數(shù)的創(chuàng)建和調(diào)用

什么是函數(shù),函數(shù)就是執(zhí)行特定任何以完成特定的功能的一段代碼
為什么需要函數(shù)

1. 代碼復(fù)用
2. 隱藏實現(xiàn)細節(jié)
3. 提高可維護性
4. 提高可讀性便于調(diào)試

函數(shù)的創(chuàng)建

def 函數(shù)名([輸入?yún)?shù)]):
  函數(shù)體
  [return xxx]

def calc(a,b):
    return a+b
result=calc(10,20)
print(result)

參數(shù)傳遞

1. 位置實參
2. 關(guān)鍵字實參

def calc(a,b): #ab稱為形式參數(shù),簡稱形參,形參的位置是在函數(shù)的定義處
    return a+b
result=calc(b=10,a=20)# 10,20稱為實際參數(shù)的值,實參
print(result)
result=calc(10,20)# 10,20稱為實際參數(shù)的值,實參
print(result)
def fun(arg1,arg2):
    print(arg1,arg2)
    arg1='100'
    arg2.append(100)
    print(arg1,arg2)
    pass

n1='11'
n2=[22,33,44]
fun(n1,n2)
print(n1,n2)
# 在函數(shù)調(diào)用過程中進行參數(shù)傳遞,如果是不可變對象,在函數(shù)體的修改不會影實參的值
# 如果是可變對象,在函數(shù)體的修改會影響到實參的值

def fun(num):
    odd=[]# 存計數(shù)
    even=[]# 存偶數(shù)
    for i in num:
        if i%2:
            odd.append(i)
        else:
            even.append(i)
            pass
        pass
    return odd,even
    pass
lst=[10,29,34,23,44,53,55]
print(fun(lst))
# 如果函數(shù)沒有返回值,return可以省略不寫
# 函數(shù)的返回值如果是1個直接返回原類型,
# 函數(shù)的返回值如果是多個,返回結(jié)果為元組

函數(shù)定義默認值參數(shù)

1. 函數(shù)定義時,給形參設(shè)置默認值,只有與默認值不符的時候擦才會傳遞實參

def fun(a,b=10):
    return a+b
    pass
print(fun(110))

函數(shù)的參數(shù)定義

1. 個數(shù)可變的位置參數(shù)
   1. 在定義函數(shù)的時候,可能無法確定傳遞參數(shù)的個數(shù)時,使用可變的位置參數(shù)
   2. 使用*定義個數(shù)可變的位置形參
   3. 結(jié)果為一個元組
2. 個數(shù)可變的關(guān)鍵字參數(shù)
   1. 定義函數(shù)時,無法事先確定傳遞的關(guān)鍵字實參的個數(shù)時,使用可變的關(guān)鍵字形參
   2. 使用**定義可變的關(guān)鍵字形參
   3. 結(jié)果為一個字典

def fun(*arge):
    print(arge)
    pass
fun(111)

def fun(**arge):
    print(arge)
    pass
fun(a='1',b='2')
def fun(*,e): # 則表示調(diào)用時傳入必須使用關(guān)鍵字參數(shù)傳遞
    print(e)
    pass
fun(e=123)

def fun(a,b,c):
    print(a,b,c)
    pass
fun(10,20,30)
lst=[11,22,33]
fun(*lst)# 在函數(shù)調(diào)用時,將列表中每隔元素都轉(zhuǎn)換為位置實參傳入
fun(a=100,c=30,b=1)#關(guān)鍵字參數(shù)
dic={'a':11,'b':22,'c':33}
fun(**dic)
def fun4(a,b,*,c,d):#前兩個參數(shù),采用的是位置實參傳遞,而CD采用的是關(guān)鍵字實參傳遞
    print(a)
    print(b)
    print(c)
    print(d)

print(fun4(10,20,c=30,d=40))
def fun5(a,b,*,c,d,**args):
    pass
def fun6(*args,**args2):
    pass
def fun7(a,b=10,*args,**args2):
    pass

注意傳入?yún)?shù)的位置：

def fun_a(a,name='開心呢',*args,**kwargs):
    print(a)
    print(name)
    print(args)
    print(kwargs)

fun_a(100,'張三',1000,2000,x=1,y=2)

變量的作用域

def fun(a,b):
    c=a+b
    print(c)
    pass
name="aidfjiajsdf"
print(c)#c是在函數(shù)體內(nèi)是局部變量在全局中是無法調(diào)用的;
print(name)
def fun2():
    global name #聲明變量是全局變量,然后就可以修改全局變量啦
    name=10
    print(name)
fun2()
print(name)

遞歸函數(shù)

1. 如果在一個函數(shù)的函數(shù)體內(nèi)調(diào)用了改函數(shù)本身,這個函數(shù)就成為遞歸函數(shù)
2. 遞歸的組成部分:遞歸調(diào)用與遞歸傳遞終止條件
3. 遞歸的調(diào)用過程:每遞歸調(diào)用一次函數(shù),都會在棧內(nèi)存分配一個棧幀,每執(zhí)行完一次函數(shù),都會釋放相應(yīng)的控件
4. 遞歸的額優(yōu)缺點,缺點:占用內(nèi)存多,效率低下,優(yōu)點:思路和代碼簡單

def fac(n):
    if n ==1:
        return 1
    else:
        return n*fac(n-1)
print(fac(6))

def fib(n):
    if n==1:
        return 1
    elif n==2:
        return 1
    else:
        return fib(n-1)+fib(n-2)
#斐波那契數(shù)列第6位上的數(shù)字
print(fib(6))
for i in range(1,7):
    print(fib(i))

閉包函數(shù)

def power(exp):
    def exp_off(base):
        return base ** exp
    return exp_off
square = power(2)
cube = power(3)
print(square(2))
print(cube(3))

參數(shù)的解包

def fun_a(x,y,z):
    print(x,y,z)

fun_a(1,2,3)
a=(1,2,3)
# 元素解包操作,在a前面加一個*號則會進行元組的解包,如果加上**進行字典的解包
fun_a(*a)

高階函數(shù)

所謂高階函數(shù),需要滿足下面兩個條件之一

1. 接受一個或多個函數(shù)作為參數(shù)
2. 輸出一個函數(shù)

# map是要給映射,接受兩個參數(shù),第一個i而參數(shù)是一個函數(shù),第二個參數(shù)是序列(列表/元組)
# 返回值:可迭代對象
list_a=[1,2,3,4,5]
list_b=[]
for item in list_a:
    list_b.append(item+10)
print(list_b)
# 結(jié)果:[11, 12, 13, 14, 15]
# 思考list_b中的數(shù)據(jù)由list_a中的數(shù)據(jù)根據(jù)規(guī)則生成得出

mapretul =map(lambda x:x+10,list_a)
print(list(mapretul))
# 打印結(jié)果:[11, 12, 13, 14, 15]


def add(a,b):
    return a+b
def sub(a,b):
    if a<=0:
        raise ValueError('傳入的a太小啦不夠減')
    return a-b

def calc(opr):
    if opr=='+':
        return add
    elif opr=='-':
        return sub
    else:
        raise ValueError('傳入的數(shù)據(jù)錯誤')

f1=calc('+')
f2=calc('-')
print('10+5=%d'% f1(10,5))
print('10-5=%d'% f2(0,5))

# 打印結(jié)果
10+5=15
Traceback (most recent call last):
  File "C:\Users\sj176\PycharmProjects\erlangshen_app_test-master\erlangshen_app_test-master\testmu.py", line 19, in <module>
    print('10-5=%d'% f2(0,5))
  File "C:\Users\sj176\PycharmProjects\erlangshen_app_test-master\erlangshen_app_test-master\testmu.py", line 5, in sub
    raise ValueError('傳入的a太小啦不夠減')
ValueError: 傳入的a太小啦不夠減

python自帶的函數(shù)

過濾函數(shù)filter

def fun_a(a):
    return a>50
data1=[1,2,3,4,5,11,22,33,44,55,66,77,88,223]
filed=filter(fun_a,data1) # 返回一個迭代對象
#調(diào)用list轉(zhuǎn)換為list
print(list(filed))
打印結(jié)果
[55, 66, 77, 88, 223]

映射函數(shù)map
map（）函數(shù)用于對容器中的元素進行映射（或變換）。例如：我
想將列表中的所有元素都乘以2，返回新的列表。

def f1(x):
    return x*2

listData=[1,2,3,4,5,6]
mapData=map(f1,listData)
print(list(mapData))
打印結(jié)果
[2, 4, 6, 8, 10, 12]

lambda（）函數(shù)

在Python中使用lambda關(guān)鍵字定義匿名函數(shù)。lambda關(guān)鍵字定義的
函數(shù)也被稱為lambda（）函數(shù)，定義lambda（）

def calc(opr):
    if opr=='+':
        return lambda a,b:(a+b)
    elif opr=='-':
        return lambda a,b:(a-b)
    else:
        raise ValueError('傳入的數(shù)據(jù)錯誤')

f1=calc('+')
f2=calc('-')
print('10+5=%d'% f1(10,5))
print('10-5=%d'% f2(0,5))



listData=[1,2,3,4,5,6]
mapData=map(lambda x:x*2,listData)
print(list(mapData))

reduce

對每個元素進行處理,
走的邏輯是
第一次x是2y是3進行乘操作=6
第二次x是6y是4進行乘操作=24
以此類推

list_a = [2,3,4,4,12,3]
ret=1
for item in list_a:
    ret*=item

print(ret)
from functools import reduce
# 對每個元素進行累乘
ret=reduce(lambda x,y:x*y,list_a)
print(ret)

BUG

BUG的常見類型

1. 粗心導致的語法錯誤SyntaxError
2. 粗心導致的錯誤寶典
   1. 漏了末尾的冒號,如果if語句,循環(huán)語句,else子句等
   2. 縮進錯誤,改縮進沒有縮進,不該縮進的瞎縮進
   3. 把英文符號寫成中文符號,比如所:引號,冒號,括號
   4. 字符串拼接的時候,把字符串和數(shù)字拼接在一起
   5. 沒有定義變量,比如所while循環(huán)條件的變量
   6. ==比較運算符和=復(fù)制運算符的混用
3. BUG的常見類型
   1. 索引越界問題indexError
   2. append()方法使用的掌握不熟練
4. BUG的常見類型
   1. 思路不清導致的問題解決方案
   2. 使用print()函數(shù)

魔法函數(shù)

1. str：字符串方法
2. lt:小于、大于符號比較
3. le:小于等于、大于等于符號比較
4. eq==符號比較

代碼演示

class Student:
    def __init__(self,name,age):
        self.name=name
        self.age=age

    def __str__(self): # 默認打印的是對象的內(nèi)存地址
        return '姓名{}，年齡{}'.format(self.name,self.age)
    def __lt__(self, other):
        return self.age<other.age
    def __le__(self, other):
        return self.age<=other.age
    def __eq__(self, other):
        return self.name==other.name

stu=Student('周杰倫',19)
stu2=Student('周杰倫',19)
print(stu)
# 姓名周杰倫，年齡19
# 進行對比Student的年齡看誰大
print(stu>stu2) # 如果不重寫lt則會進行報錯 打印,用于< or >
# 打印結(jié)果False
print(stu>=stu2) # 如果不重寫le則會進行報錯 打印,用于<= or >=
print(stu==stu2) # 如果沒有實現(xiàn)eq方法，則默認比較內(nèi)存地址

類型注解

為什么我們需要注解？，在使用pycharm過程中，在使用方法體傳入的內(nèi)容的方法時，不會有提示，其實就是應(yīng)為pycharm無法通過代碼判斷自動補全
使用方法后pycharm會有提示該方法傳入的什么參數(shù)

變量的類型注解

基礎(chǔ)語法：變量:類型
實例代碼

# 基礎(chǔ)類型注解
import json
import random


class Student:
    pass
stu:Student=Student()
var_1:int = 10
var_2:str='it'
my_list:list=[1,2,3]
my_list2:list[int]=[1,2,3]# 詳細注解
my_tuple2:tuple[int,str,bool]=(1,'2',True) # 詳細注解
my_dict:dict[str,int]={'key':123}
# 注意元組類型設(shè)置類型詳細注解，需要將每一個元素都標記出來
# 字典類型設(shè)置類型詳細注解，需要2各類型，第一個時key，第二個時value
# 除了使用變量：類型，這種語法做注解外，也可以在注解中進行類型注解。
# 語法
var_8=random.randint(1,10)# type:int
var_9=json.loads('{"name":"zhangsan"}') # type:dict[str,str]
def fun():
    return 10
var_10=fun()#type:int

如下方展示，就算不寫注解，也明確知曉變量類型，就不需要注解啦

stu:Student=Student()
var_1:int = 10
var_2:str='it'
my_list:list=[1,2,3]
my_list2:list[int]=[1,2,3]# 詳細注解
my_tuple2:tuple[int,str,bool]=(1,'2',True) # 詳細注解
my_dict:dict[str,int]={'key':123}

如果是下方，一眼看不明白的可以使用類型注解

var_8=random.randint(1,10)# type:int
var_9=json.loads('{"name":"zhangsan"}') # type:dict[str,str]
def fun():
    return 10
var_10=fun()#type:int

注意類型注解只是備注，如果寫錯了也不會程序報錯

函數(shù)（方法）形參的注解

函數(shù)（方法）形參列表和返回值類型注解
語法：
def 函數(shù)名（形參名：類型，形參名：類型）
pass

Union類型

問題:如果list中或字典中存在多種類型那么就需要使用Union類型來注解
簡單使用

from typing import Union
myList:list[Union[str,int]]=[1,2,'e','f']
mydict:dict[str,Union[str,int]]={"name":1,'eee':2,"d":'e',"f":'f'}

def func(data:Union[int,str])->Union[int,str]:# 傳入返回字符串或者int類型
    pass