Python学习

这里总结的是自己看视频的笔记、不是教程哟、所以顺序会有点乱！

Python是什么

简介

Python是一种跨平台的计算机程序设计语言。是一个高层次的结合了解释性、编译性、互动性和面向对象的脚本语言。最初被设计用于编写自动化脚本(shell)，随着版本的不断更新和语言新功能的添加，越多被用于独立的、大型项目的开发。

安装

这个是我B站的安装教程

基础知识

注释的使用

Python中通过 #、""" 来进行注释

# 这是一个单行注释

"""
这是
多行
注释
"""

快捷键的使用

注释与反注释快捷键 ctrl + /
格式化代码 ctrl + alt + L

print

print: 用于向控制台输出内容

print("Hello World!")

# 多个字符串可以使用逗号分隔 遇到逗号会有一个空格
print("Hello World", "Hello old world", "Hello new world") # Hello World Hello old world Hello new world

# 直接进行运算
print(1 + 2)  # 3

# 直接输出数字
print(3)  # 3

# 类似字符串拼接
print("1 + 2 =", 3) # 1 + 2 = 3

关键字

import keyword  # 导入keyword模块查看关键字

# 查看关键字
print(keyword.kwlist)
# ['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']

变量的使用

input

input(): 从外部获取变量

1
2
3

num1 = int(input("请输入一个数字："))
num2 = int(input("请再输入一个数字："))
print("num1 + num2 =", num1 + num2)

程序执行过程

自上而下运行(面向过程)

age = "good"

# 查看变量的地址
print(id(age)) # 2252210608592 会变化的

# type 可以查看变量类型
print(type(age)) # <class 'str'>

del age # 删除后变量无法引用
print("age =", age) # NameError: name 'age' is not defined

变量的定义

1 2	num3 = 10 num4 = num3 # 将num3的值赋值给num4

可以连续定义多个变量

1
2
3

num5 = num6 = num7 = 1
print(num3, num4, num5, num6, num7)
# 10 10 1 1 1

交互式定义变量

num5, num6 = 5, 6
print(num5, num6) # 5 6

f1 = 1.1
f2 = 2.2
f3 = f1 + f2
print(f3) # 3.3000000000000003

数字类型转换

int()：将一个数值或字符串转换成整数，可以指定进制。
float()：将一个字符串转换成浮点数。
str()：将指定的对象转换成字符串形式，可以指定编码。
chr()：将整数转换成该编码对应的字符串（一个字符）。
ord()：将字符串（一个字符）转换成对应的编码（整数）。

print(int(1.9))  # 1
print(float(1))  # 1.0
print(str("A"))  # A
print(chr(65))  # A
print(ord("a"))  # 97

数据类型

string 字符串

以单引号或双引号括起来的任意文本 'abc' "def"
字符串不可变

创建

1
2
3

str1 = "Hello World!"
str2 = "Hello New World!"
str3 = "New World"

字符串运算

字符串连接拼接

str4 = "Hello "
str5 = "World"
str6 = str4 + str5
print("str4 = ", str4) # str4 =  Hello
print("str5 = ", str5) # str5 =  World
print("str6 = ", str6) # str6 =  Hello World

输出重复字符串

1
2
3

str7 = "good"
print(str7 * 3)
# goodgoodgood

索引取值

访问字符串中的某一个字符
通过索引下标查找字符，索引从0开始

str8 = "I have a computer"
print(str8[3]) # a

# str2[3] = "A" # 错误 字符串不可变
# print(str8)

字符串截取

切片操作: sname[start:end:step]

1
2
3

str9 = "sunck is a good man!"
str10 = str9[6:15]
print(str10) # is a good

截取字符串的全部字符

1 2	str10 = str9[:] print(str10) # sunck is a good man!

从头开始截取
1
2
str10 = str9[:5]
print(str10) # sunck
从给定下标处开始截取到结尾
1
2
str10 = str9[16:]
print(str10) # man!
截取倒数第一个字符
1
2
str10 = str9[-1]
print(str10) # !

创造一个与原字符串顺序相反的字符串

1 2	str10 = str9[::-1] print(str10) # !nam doog a si kcnus

逆序截取
1
2
str10 = str9[:-5:-3]
print(str10) # !m

判断是否存在

1
2
3

str11 = "sunck is a good man!"
print("good" in str11) # True
print("good1" not in str11) # True

格式化输出

num = 10
f = 3.1415923635
print("num =", num)  # 会四舍五入 num = 10
print("num = %d  str11 = %s  f = %.10f" % (num, str11, f)) 
# num = 10  str11 = sunck is a good man!  f = 3.1415923635

转义字符

转换成有特殊含义的字符

\n 换行

print("num = %d\nstr11 = %s\nf = %.10f" % (num, str11, f))
"""
num = 10
str11 = sunck is a good man!
f = 3.1415923635
"""
print("suck \\n is") # suck \n is

print('tom is \'good\' man') # tom is 'good' man
print("tom is 'good' man") # tom is 'good' man

如果字符串内有很多换行，用\n写在一行不好阅读

print("good\nman\nhandsome")
"""
good
man
handsome
"""
print("""good
man
handsome""")
"""
good
man
handsome
"""

\t 制表符
1
print("good\tman") # good man
前面加r为默认不转义
1
print(r"\\t\\") # \\t\\
字符串方法

eval(str)：将字符串str当成有效的表达式来并返回计算结果

num1 = eval("123")
print(num1) # 123
print(type(num1)) # <class 'int'>
print(eval("+123")) # 123
print(eval("-123")) # -123
print(eval("12+3")) # 15
print(eval("12-3")) # 9

len(str)：返回字符串的长度(字符个数)
1
print(len("sunck is a good man")) # 19

str.lower(): 转换字符串中的大写字母为小写字母

1 2	str12 = "SUNCK is a good man" print(str12.lower()) # sunck is a good man

str.upper()：转换字符串中的小写字母为大写字母

print(str12.upper()) # SUNCK IS A GOOD MAN
print("sunck is a good man".upper()) # SUNCK IS A GOOD MAN

print("原字符串", str12) # 原字符串 SUNCK is a good man

str.swapcase(): 大写变小写小写变大写

1	print("SuNcK iS a GoOd MaN".swapcase()) # sUnCk Is A gOoD mAn

str.capitalize() 首字母大写其他字母小写

1	print("SuNcK iS a GoOd MaN".capitalize()) # Sunck is a good man

str.title(): 每个首字母大写其他字母小写

1	print("SuNcK iS a GoOd MaN".title()) # Sunck Is A Good Man

str.center(width,fillchar)
width: 返回一个指定宽度的居中字符串
fillchar: 填充的字符串(默认为空格填充)
1
print("SuNcK iS a GoOd MaN".center(25, "*")) # ***SuNcK iS a GoOd MaN***
str.ljust(width[,fillchar])
width: 返回一个指定宽度的左对齐字符串
fillchar: 填充的字符串(默认为空格填充)
1
print("SuNcK iS a GoOd MaN".ljust(25, "%")) # SuNcK iS a GoOd MaN%%%%%%

str.rjust(width[,fillchar])
width: 返回一个指定宽度的右对齐字符串
fillchar: 填充的字符串(默认为空格填充)
1
print("SuNcK iS a GoOd MaN".rjust(25, "%")) # %%%%%%SuNcK iS a GoOd MaN

str.zfill(width)
返回一个长度为width的字符串，原字符串右对齐，前面补0
1
print("SuNcK iS a GoOd MaN".zfill(25)) # 000000SuNcK iS a GoOd MaN

str.count(str[,start][,end])
返回指定字符串str出现的次数默认从头到尾
1
print("ha Very Very is a man ,ha ha ha".count("Very", 3, 12)) # 2

str.find(str[,start][,end])

从左向右检测str字符串是否包含在字符串中默认从头到尾得到第一次出现返回的下标没有返回-1

1
2
3

print("ha Very Very is a man ,ha ha ha".find("Very")) # 3
print("ha Very Very is a man ,ha ha ha".find("Good")) # -1
print("ha Very Very is a man ,ha ha ha".find("Very", 7)) # 8

str.rfind(str[,start][,end])

从右向左检测str字符串是否包含在字符串中得到第一次出现返回的下标没有返回-1

1
2
3

print("ha Very Very is a man ,ha ha ha".rfind("Very")) # 8
print("ha Very Very is a man ,ha ha ha".rfind("Good")) # -1
print("ha Very Very is a man ,ha ha ha".rfind("Very", 7)) # 8

str.index(str[,start][,end])
和find()一样不过str不存在时会报异常
1
print("ha Very Very is a man ,ha ha ha".index("Very")) # 3

str.rindex(str[,start][,end])
和rfind()一样不过str不存在时会报异常
1
print("ha Very Very is a man ,ha ha ha".rindex("Very")) # 8

lstrip(): 截取字符串左侧指定的字符默认为空格

1 2	print("***********ha Very Very is a man ,ha ha ha".lstrip("")) # ha Very Very is a man ,ha ha ha

rstrip(): 截取字符串右侧指定的字符默认为空格

1 2	print("ha Very Very is a man ,ha ha ha***********".rstrip("")) # ha Very Very is a man ,ha ha ha

strip()截取字符串左右指定的字符默认为空格

print("***********ha Very Very is a man ,ha ha ha***********".strip("*"))
# ha Very Very is a man ,ha ha ha

str = "a"
print(ord(str)) # 97
print(chr(65)) # A
print("a" == "a") # true

字符串比较大小
从第一个字符开始比较谁的ANSII值大谁就大如果相等会比较下一个字符串的ANSII值谁值大谁就大
1
print("ms" == "ms") # \0

split(str="",num)

以str为分隔符截取字符串指定num 则仅截取num个字符串

str13 = "sunck**is******a***good*man"
list1 = str13.split("*")
print(list1) # ['sunck', '', 'is', '', '', '', '', '', 'a', '', '', 'good', 'man']
c = 0
for s in list1:
    if len(s) > 0:
        c += 1
print(c) # 5

splitlines([keepends]) 按照(‘\r’,’\r\n’,’\n’)分隔

keepends == True 会保留换行符

str14 = """sunck is a good man!
sunck is a nice man!
sunck is a handsome man!
"""
print(str14.splitlines()) 
# ['sunck is a good man!', 'sunck is a nice man!', 'sunck is a handsome man!']

join() : 以指定的字符串分隔符，将seq中的所有元素组合成一个字符串

1
2
3

list2 = ['sunck', 'is', 'a', 'good', 'man']
str15 = " ".join(list2)
print(str15) # sunck is a good man

max() min() 最大值和最小值

1
2
3

str16 = "sunck is a good man!z"
print(max(str16)) # z
print("*" + min(str16) + "*") # 是一个空格 * *

replace(oldstr,newstr,count)

用newstr替换oldstr，默认是全部替换，如果指定了count，那么只替换前count个

str17 = "sunck is a good good good man!"
str18 = str17.replace("good", "nice", 1)
print(str17) # sunck is a good good good man!
print(str18) # sunck is a nice good good man!

创建一个字符串映射表

参数：要转换的字符串目标字符串

t19 = str.maketrans("ac", "65")
# a--6    c--5
str20 = "sunck is a good man!"
str21 = str20.translate(t19)
print(str21) # sun5k is 6 good m6n!

startswith(str,start=0,end=len(str))
在给定范围内判断是否以str开头，没有指定范围，默认为整个字符串
1
2
str22 = "sunck is a good man!"
print(str22.startswith("sunck", 5, 16)) # False

endswith(str,start=0,end=len(str))
在给定范围内判断是否以str结尾，没有指定范围，默认为整个字符串
1
2
str22 = "sunck is a good man!"
print(str22.endswith("man", 5, 16)) # False

encode(encoding="utf-8",errors="strict") 编码

注意：要与编码时的编码格式一致

str23 = "sunck is a good man凯!"

ignore 忽略错误

1
2
3

data52 = str23.encode("utf-8", "ignore")
print(data52) # b'sunck is a good man\xe5\x87\xaf!'
print(type(data52)) # <class 'bytes'>

解码

1 2	str24 = data52.decode("gbk", "ignore") print(str24) # sunck is a good man鍑!

isalpha()
如果字符串中至少有一个字符且所有字符都是字母返回True，否则返回False
1
2
str25 = "sunck is a good man!"
print(str25.isalpha()) # False

isalnum()
如果字符串中至少有一个字符且所有字符都是数字或字母返回True，否则返回False
1
2
str26 = "1a2b3"
print(str26.isalnum()) # True

isupper()

如果字符串中至少有一个英文字符且所有字符都是大写的英文字符返回True，否则返回False

print("ABC".isupper()) # True
print("1".isupper()) # False
print("c".isupper()) # False
print("ABC1".isupper()) # True
print("ABC#".isupper()) # True

islower()

如果字符串中至少有一个英文字符且所有字符都是小写的英文字符返回True，否则返回False

print("abc".islower()) # True
print("abcA".islower()) # False
print("1".islower()) # False
print("abc1".islower()) # True
print("abc#".islower()) # True

istitle()
如果字符串是标题化的返回True，否则返回False
1
print("Sunck Is".istitle()) # True

isdigit()
如果字符串中只包含数字字符返回True，否则返回False
1
print("123".isdigit()) # True

isnumeric() 同上
如果字符串中只包含数字字符返回True，否则返回False
1
print("1234".isnumeric()) # True

isdecimal()

字符串只包含十进制字符

1 2	print("123".isdecimal()) # True print("123z".isdecimal()) # True

isspace()

如果字符串中只包含空格则返回True，否则返回False

print(" ".isspace()) # True
print("      ".isspace()) # True
print("\t".isspace()) # True
print("\n".isspace()) # True
print("\r".isspace()) # True
print("\f".isspace())  True

可变字符串

import io
s = "hello world"
sio = io.StringIO(s) 
print(sio) # <_io.StringIO object at 0x0000025EBF11A0D8>
print(sio.getvalue()) # hello world
print(sio.seek(7)) # 7
sio.write("a")
print(sio.getvalue()) # hello warld

list 列表

列表：是一种有序的集合

创建列表

格式：列表名 = [列表选项1,列表选项2,列表选项3,......]

创建空列表

1	list1 = []

创建带有元素的列表

list2 = [1, 2, 3, 4, 5, 6, 7, 8, 9]
index = 0
sum = 0
while index < 5:
    sum += list2[index]
    index += 1
    if index == 5:
        print("平均年龄:%d" % (sum / 5)) # 平均年龄:3
print(list2) # [1, 2, 3, 4, 5, 6, 7, 8, 9]

元素可以是其他类型

1 2	list3 = [1, 2, "sunck", "good", True] print(list3) # [1, 2, 'sunck', 'good', True]

列表元素的访问

注意不要越界(下标超出了可表示的范围)

格式：列表名[下标]

1 2	list4 = [1, 2, 3, 4, 5] print(list4[2]) # 3

替换

1 2	list4[2] = 300 print(list4) # [1, 2, 300, 4, 5]

列表操作

列表组合

list5 = [1, 2, 3]
list6 = [4, 5, 6]
list7 = list5 + list6
print(list7) # [1, 2, 300, 4, 5]

列表的重复

1 2	list8 = [7, 8, 9] print(list8 * 3) # [7, 8, 9, 7, 8, 9, 7, 8, 9]

判断元素是否在列表中

1
2
3

list9 = [1, 2, 3, 4, 5]
print(3 in list9) # True
print(6 in list9) # False

列表截取

list10 = [1, 2, 3, 4, 5, 6, 7, 8, 9]
print(list10[2:6]) # [3, 4, 5, 6]
print(list10[3:]) # [4, 5, 6, 7, 8, 9]
print(list10[:5]) # [1, 2, 3, 4, 5]

二维列表

1
2
3

list11 = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
print(list11[1]) # [4, 5, 6]
print(list11[1][2]) # 6

列表方法

append()

在列表末尾添加一个元素

list12 = [1, 2, 3, 4, 5]
list12.append(6)
list12.append([7, 8, 9])
print(list12) # [1, 2, 3, 4, 5, 6, [7, 8, 9]]

extend()

在末尾一次性追加另一个列表中的多个值

1
2
3

list13 = [1, 2, 3, 4, 5]
list13.extend([6, 7, 8])
print(list13) # [1, 2, 3, 4, 5, 6, 7, 8]

insert()

在下标处添加一个元素，不覆盖原数据，原数据向后移动一个

list14 = [1, 2, 3, 4, 5]
list14.insert(0, 0)
list14.insert(2, [100, 200])
print(list14) # [0, 1, [100, 200], 2, 3, 4, 5]

pop(x=list[-1])

移除列表中的指定下标处的元素(默认移除最后一个元素)

list15 = [1, 2, 3, 4, 5]
print(list15[-1]) # 5
list15.pop()
list15.pop(2)
print(list15) # [1, 2, 4]

remove()

移除列表中的某个元素第一个匹配的结果

1
2
3

list16 = [1, 2, 3, 4, 5, 4]
list16.remove(4)
print(list16) # [1, 2, 3, 5, 4]

clear()

清除列表中的所有元素

1
2
3

list17 = [1, 2, 3, 4, 5]
list17.clear()
print(list17) # []

index()

从列表中找出某个值第一个匹配的索引值

1
2
3

list18 = [1, 2, 3, 4, 5, 3, 4, 5, 6, 7]
listA = [1, 2, 3, 4, 5, 3, 4, 5, 6, 7]
list18 = list18.index(3)

圈定范围

1
2
3

index19 = listA.index(3, 3, 7)
print(list18) # 2
print(index19) # 5

列表中有多少个元素

1 2	list20 = [1, 2, 3, 4, 5] print(len(list20)) # 5

max()

获取列表中的最大值

1 2	list21 = [1, 2, 3, 4, 5] print(max(list21)) # 5

min()

获取列表中的最小值

1 2	list22 = [1, 2, 3, 4, 5] print(min(list22)) # 1

count()

返回指定元素在列表出现的次数

list23 = [1, 2, 3, 4, 5, 3, 4, 5, 3, 3, 5, 6]
print(list23.count(3)) # 4

num24 = 0
all = list23.count(3)
while num24 < all:
    list23.remove(3)
    num24 += 1
print(list23) # [1, 2, 4, 5, 4, 5, 5, 6]

reverse() 倒序

1
2
3

list25 = [1, 2, 3, 4, 5]
list25.reverse() 
print(list25) # [5, 4, 3, 2, 1]

sort() 排序

1
2
3

list26 = [5, 2, 1, 4, 3]
list26.sort()  # 升序
print(list26) # [1, 2, 3, 4, 5]

拷贝

浅拷贝引用拷贝

list27 = [1, 2, 3, 4, 5]
list28 = list27
list28[1] = 200
print(list28) # [1, 200, 3, 4, 5]
print(list27) # [1, 200, 3, 4, 5]
print(id(list28)) # 1800606173064
print(id(list27)) # 1800606173064

深拷贝内存拷贝

list29 = [1, 2, 3, 4, 5]
list30 = list29.copy()
list30[1] = 200
print(list29) # [1, 2, 3, 4, 5]
print(list30) # [1, 200, 3, 4, 5]
print(id(list29)) # 1800606173000
print(id(list30)) # 1800606173128

案例

import copy

## 浅拷贝 不拷贝子对象的内容，只是拷贝子对象的引用
a = [10, 20, [5, 6]]
b = copy.copy(a)
print("a:", a) # a: [10, 20, [5, 6]]
print("b:", b) # a: [10, 20, [5, 6]]
b.append(30)
b[2].append(7)
print("浅拷贝...")
print("a:", a) # a: [10, 20, [5, 6, 7]]
print("b:", b) # b: [10, 20, [5, 6, 7], 30]
print("------------浅拷贝...---------------")

## 深拷贝 会连对象的内存也全部拷贝一份，对子对象的修改不会影响源对象
a = [10, 20, [5, 6]]
b = copy.deepcopy(a)
print("a:", a) # b: [10, 20, [5, 6]]
print("b:", b) # b: [10, 20, [5, 6]]
b.append(30)
b[2].append(7)
print("深拷贝...")
print("a:", a) # a: [10, 20, [5, 6]]
print("b:", b) # b: [10, 20, [5, 6, 7], 30]
print("------------深拷贝...---------------")

将元组转成列表

1 2	list31 = list((1, 2, 3, 4)) print(list31) # [1, 2, 3, 4]

list 去重

l = [1, 2, 3, 4, 3, 4, 5, 6]

## 1
## s = set(l)
## l = list(s)
## print(l)

## 2
l = list(set(l))
print(l) # [1, 2, 3, 4, 5, 6]

列表推导式

"""
list = [Expression for var in range]
参数说明：
list:列表名称
Expression:表达式，用于计算新列表的元素
var:循环变量
range:采用range()函数生成的range对象
"""
multiples = [i for i in range(30) if i % 3 is 0]
print(multiples) # [0, 3, 6, 9, 12, 15, 18, 21, 24, 27]
print(type(multiples)) # <class 'list'>

zip

将多个列表对应位置的元素组合成为元组，并返回这个zip对象

a = [10, 20, 30]
b = [40, 50, 60]
c = [70, 80, 90]
d = zip(a, b, c)
print(d) # <zip object at 0x000001A33C7EF248>
print(list(d)) # [(10, 40, 70), (20, 50, 80), (30, 60, 90)]

tuple 元组

创建空的元组

1 2	tuple1 = () print(tuple1) # ()

创建带有元素类型的元组

元组中的元素的类型可以不同

1 2	tuple2 = (1, 2, 3, "good", True) print(tuple2) # (1, 2, 3, 'good', True)

定义只有一个元素的元组

1
2
3

tuple3 = (1,)
print(tuple3) # (1,)
print(type(tuple3)) # <class 'tuple'>

元组元素的访问

格式：元组名[下标] 下标从0开始

取值

tuple4 = (1, 2, 3, 4, 5)
print(tuple4[0]) # 1
print(tuple4[4]) # 5
## print(tuple4[5]) #下标越界

## 获取最后一个元素
print(tuple4[-1]) # 5

## 
print(tuple4[-2]) # 4
print(tuple4[-5]) # 1

元组中的元素不可以修改

tuple5 = (1, 2, 3, 4, [5, 6, 7])

## tuple5[0] = 100 #元组不可变
## tuple5[-1] = [7, 8, 9] # 元素不可变
tuple5[-1][0] = 500
print(tuple5) # (1, 2, 3, 4, [500, 6, 7])

删除元组 del

1
2
3

tuple6 = (1, 2, 3)
del tuple6
## print(tuple6)

元组的操作

t7 = (1, 2, 3)
t8 = (4, 5, 6)
t9 = t7 + t8
print(t9) # (1, 2, 3, 4, 5, 6)
print(t7 + t8) # (1, 2, 3, 4, 5, 6)

元组重复

1 2	t10 = (1, 2, 3) print(t10 * 3) # (1, 2, 3, 1, 2, 3, 1, 2, 3)

判断元素是否在元组中

1 2	t11 = (1, 2, 3) print(4 in t11) # False

元组的截取

格式：元组名[开始下标:结束下标]

从开始下标开始截取，截取到结束下标之前

t12 = (1, 2, 3, 4, 5, 6, 7, 8, 9)
print(t12[3:7]) # (4, 5, 6, 7)
print(t12[3:]) # (4, 5, 6, 7, 8, 9)
print(t12[:7]) # (1, 2, 3, 4, 5, 6, 7)

二维元组元素为一维元组

1 2	t13 = ((1, 2, 3), (4, 5, 6), (7, 8, 9)) print(t13[1][1]) # 5

元组的方法

len()

返回元组中元素的个数

1 2	t14 = (1, 2, 3, 4, 5) print(len(t14)) # 5

max()

返回元组中的最大值

1 2	t15 = (1, 2, 3, 4, 5) print(max(t15)) # 5

min()

返回元组中的最小值

1 2	t16 = (1, 2, 3, 4, 5) print(min(t16))

将列表转成元组 tuple()

1
2
3

list1 = [1, 2, 3]
tuplea = tuple(list1)
print(tuplea) # (1, 2, 3)

元组的遍历

for x in (1, 2, 3, 4, 5):
    print(x)
"""
1
2
3
4
5
"""

元组推导式

a = [1, 2, 3, 4, 5, 6, 7, 8]
f = (i ** 2 for i in a)
for n in f:
    print(n)
print(type(f))  # 生成器 <class 'generator'>
"""
1
4
9
16
25
36
49
64
"""

dict 字典

使用键-值(key-value)存储，具有极快的查找速度

注意：字典是无序的

key的特性：

字典中的key必须唯一
key必须是不可变对象
字符串、整数等都是不可变的，可以作为key
list是可变的，不能作为key

创建字典

空字典 dict = {}

1	dict1 = {"tom": 60, "lilei": 70}

fromkeys函数

使用给定的键建立新的字典，键默认对应的值为None

1 2	d = dict.fromkeys(['one', 'two', 'three']) print(d) # {'one': None, 'two': None, 'three': None}

通过zip()创建字典对象

k = ['name','age','job']
v = ['haha',18,'player']
d = dict(zip(k,v))
print(d) # {'name': 'haha', 'age': 18, 'job': 'player'}

元素的访问

获取

字典名[key] 或 get

print(dict1["tom"]) # 60
print(dict1.get("sunck")) # None
ret = dict1.get("sunck")
if ret == None:
    print("没有") # 没有
else:
    print("有")

添加

1	dict1["hanmeimei"] = 99

因为一个key对应一个value,所以多次对一个key的value赋值，其实就是修改值

1 2	dict1["lilei"] = 80 print(dict1) # {'tom': 60, 'lilei': 80, 'hanmeimei': 99}

删除

pop

1 2	dict1.pop("tom") print(dict1) # {'lilei': 80, 'hanmeimei': 99}

popitem 移出字典中的最后一项

1 2	dict1.popitem() print(dict1) # {'lilei': 80}

遍历

for key in dict1:
    print(key, dict1[key]) # lilei 80

for value in dict1.values():  # [80,99]
    print(value) # 80
    
## 使用字典对象的items()方法可以获取字典的“键值对”列表   
## print(dict1.items())
for k, v in dict1.items():
    print(k, v) # lilei 80

for i, v1 in enumerate(dict1):
    print(i, v1) # 0 lilei

字典推导式

大小写key合并

mcase = {'a': 10, 'b': 34, 'A': 7, 'Z': 3}
mcase_frequency = {
    k.lower(): mcase.get(k.lower(), 0) + mcase.get(k.upper(), 0)
    for k in mcase.keys()
    if k.lower() in ['a', 'b']
}
print(mcase_frequency) # {'a': 17, 'b': 34}

快速更换key和value

1
2
3

mcase = {'a': 10, 'b': 34}
mcase_frequency = {v: k for k, v in mcase.items()}
print(mcase_frequency) # {10: 'a', 34: 'b'}

和list比较

查找和插入的速度极快，不会随着key-value的增加而变慢
需要占用大量的内存，内存浪费多

list

查找和插入会随着数据量的增加而变慢
占用空间小，浪费内存少

w = input("请输入一个字符串：")

## w = "good"

str1 = "sunck is a good man!sunck is a nice man!sunck is a hands man!sunck is a good man!" \
       "sunck is a good man!sunck is a nice man!sunck is a great man!sunck is a noble man!" \
       "sunck is a cool man!"
print("字符串%s出现" % w, str1.count(w), "次")

set 集合

set: 类似dict，是一组key的集合，不存储value
本质：无序和无重复元素的集合

创建

创建set需要一个list或者tuple或者dict作为输入集合

重复元素在set中会自动被过滤

s1 = set([1, 2, 3, 4, 5, 5, 4, 3])
print(s1) # {1, 2, 3, 4, 5}
print(type(s1)) # <class 'set'>

s2 = set((1, 2, 3, 3, 2, 1))
print(s2) # {1, 2, 3}

s3 = set({1: "good", 2: "nice"})
print(s3) # {1, 2}

添加

s4 = set([1, 2, 3, 4, 5])
s4.add(6)
s4.add(3)  # 可以添加重复的，但是没有效果

## s4.add([7, 8, 9]) #set的元素不能是列表，因为列表是可变的
s4.add((7, 8, 9))
## s4.add({1: "a"})    #set的元素不能是字典，因为字典是可变的

print(s4) # {1, 2, 3, 4, 5, 6, (7, 8, 9)}

插入整个list tuple 字符串打碎插入

s5 = set([1, 2, 3, 4, 5])
s5.update([6, 7, 8])
s5.update((9, 10))
s5.update("sunck")
print(s5) # {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 'k', 'n', 'c', 'u', 's'}

删除

1
2
3

s6 = set([1, 2, 3, 4, 5])
s6.remove(3)
print(s6) # {1, 2, 4, 5}

遍历

s7 = set([1, 2, 3, 4, 5])
for i in s7:
    print(i)
"""
1
2
3
4
5
"""

set没有索引

1	print(s7[3]) # 会报错

enumerate

for index, data in enumerate(s7):
    print(index, data)
"""
0 1
1 2
2 3
3 4
4 5
"""

基本运算

1 2	s8 = set([1, 2, 3]) s9 = set([2, 3, 4])

交集 &

1
2
3

a1 = s8 & s9
print(a1) # {2, 3}
print(type(a1)) # <class 'set'>

并集 |

1
2
3

a2 = s8 | s9
print(a2) # {1, 2, 3, 4}
print(type(a2)) # <class 'set'>

差集 -

1
2
3

a3 = s8 - s9
print(a3) # {1}
print(type(a3)) # <class 'set'>

对称差运算 ^

1
2
3

a4 = s8 ^ s9
print(a4) # {1, 4}
print(type(a4)) # <class 'set'>

集合推导式

1 2	squared = {x**2 for x in [1, 1, 2]} print(squared) # {1, 4}

布尔值与空值

布尔值：True False

1
2
3

b1 = True
b2 = False
print(b1, b2) # True False

空值：None 不能理解为0

1 2	n = None print(n) # None

数据类型的类型转换

## list-->set
l1 = [1, 2, 3, 4, 5, 3, 4, 5]
s1 = set(l1)

## tuple-->set
t2 = (1, 2, 3, 4, 3, 2)
s2 = set(t2)

## set-->list
s3 = {1, 2, 3, 4}
l3 = list(s3)
print(l3) # [1, 2, 3, 4]

## set-->tuple
s4 = {2,3,4,5}
t4 = tuple(s4)
print(t4) # (2, 3, 4, 5)

运算符与表达式

算数运算符

+   -   *   /   %     **     //
加 减  乘  除  取摸  求幂  取整

算数运算表达式
1 + 1  2 * 3  a /3

num1 = 5
num2 = 3
print(num1 + num2)
print(num1 - num2)
print(num1 * num2)
print(num1 / num2)
print(num1 % num2)
print(num1 ** num2)
print(num1 // num2)

赋值运算符 =

赋值运算表达式 : 变量 = 表达式

1
2
3

num3 = 10
num4 = 10 + num3
print(num4) # 20

复合运算符

+=   a += b     a = a + b
-=   a -= b     a = a - b
*=   a *= b     a = a * b
/=   a /= b     a = a / b
%=   a %= b     a = a % b
**=  a **= b    a = a ** b
//=  a //= b    a = a // b

复合运算表达式

位运算符

按位与

& 按位与运算符
位数都为1 结果为1 否则为0

print(5 & 7) # 5
"""
101
111
---
101
"""

按位或

| 按位或运算符
有一个位数为1 结果为1 否则为0

print(5 | 7) # 7
"""
101
111
---
111
"""

按位异或

^ 按位异或运算符
二进制两位相异是结果为1

print(5 ^ 7) # 2
"""
101
111
---
010
"""

位取反

~ 按位取反运算符
每个二进制数据位取反，1变0，0变1

print(~5) # -6
"""
00000101
11111010
10000110
"""

左移运算符

<< 左移运算符
各二进制位左移动若干位由<<右侧数字决定高位丢弃低位补0

print(2 << 2) # 
"""
00000010    2
00001000    8
"""

右移运算符

>> 右移运算符
各二进制位右移动若干位由>>右侧数字决定

print(2 >> 2) # 0
"""
00000010    2
00000000    0
"""

关系运算符

关系运算符 
 ==     ！=      >       <       >=      <=   

关系运算表达式
格式： 表达式1   关系运算符   表达式2

逻辑运算符

逻辑与 and

逻辑与运算表达式表达式1 and 表达式2
有一个为假就为假

num13 = 10
num14 = 20
if num13 + 1 and num14 + 1:
    print("*************") # *************
print(num13, num14) # 10 20

短路原则

表达式1 and 表达式2 and 表达式3 and …… and 表达式n

逻辑或 or

逻辑或运算表达式表达式1 or 表达式2
有一个为真就为真

num15 = 0
num16 = 1
if num15 or num16:
    print("&&&&&&&&&&&&") # &&&&&&&&&&&&
print(num15, num16) # 0 1

表达式1 or 表达式2 or 表达式3 or …… or 表达式n

逻辑非 not

1 2	if not 0: print("%%%%%%%%%%%%") # %%%%%%%%%%%%

成员运算符

in 如果在指定的序列中找到值返回True,否则返回False
not in 如果在指定的序列中没有找到值返回True,否则返回False

身份运算符

is 判断两个标识符是不是引用同一个对象
is not 判断两个标识符是不是引用不同的对象

运算符优先级

**
~ + -(正负号[一元加减])

* / % //
+ -
>> <<
>> &
>> ^ |
>> <=  <  >  >=
>> ==  !=
>> =  %=  +=  -=  //=
>> is  is not
>> in  not in
>> not or and
>> """

条件控制语句

if 语句

if 语句
格式：
if 表达式:
    语句

if else 语句
格式：
if 表达式:
    语句1
else:
    语句2
    
如何为假？
假： 0    0.0    ''   None    False

num5 = 20
num6 = 20

if num5 == num6:
    num5 = 100
    # if 1:
    #     print("*****")
print("num5 =", num5) # num5 = 100

if-else

    if 语句
格式：
if 表达式:
    语句


    if else 语句
格式：
if 表达式:
    语句1
else:
    语句2


if elif else 语句
格式：
if 表达式1：
    语句1
elif 表达式2：
    语句2
elif 表达式3：
    语句3
……
elif 表达式n：
    语句n
else:           #可有可无
    语句n+1

age = int(input("请输入一个年龄:"))
if age < 0:
    print("未出生")
elif age <= 3:
    print("婴儿")
elif age <= 6:
    print("儿童")
elif age <= 18:
    print("青少年")
elif age <= 30:
    print("青年")
elif age <= 40:
    print("壮年")
elif age <= 50:
    print("中年")
elif age <= 100:
    print("老年")
elif age <= 150:
    print("老寿星")
else:
    print("老妖怪")

while 语句

while 语句：

while 表达式：
    语句

num = 1
while num <= 5:
    print(num)
    num += 1
"""
1
2
3
4
5
"""

## 计算1+2+3+……+100
sum = 0
num = 1
while num <= 100:
    sum += num
    num += 1
print("sum = %d" % (sum)) # sum = 5050

str = "zykj"
index = 0
while index < len(str):
    print("str[%d] = %s" % (index, str[index]))
    index += 1
"""
str[0] = z
str[1] = y
str[2] = k
str[3] = j
"""

死循环：表达式永远为真

1 2	while 1: print("hello world")

while  else 语句：

while 表达式：
    语句1
else:
    语句2

a = 1
while a <= 3:
    print("hello world")
    a += 1
else:
    print("very very good")

for 语句

for 语句
格式：
for 变量名 in 集合:
    语句

for i in [1, 2, 3, 4, 5]:
    print(i)
"""
1
2
3
4
5
"""

range

range([start,]end[,step]) 列表生成器

start默认为0，step默认为1
功能：生成数列

1
2
3

range(101)可以产生一个0到100的整数序列。
range(1, 100)可以产生一个1到99的整数序列。
range(1, 100, 2)可以产生一个1到99的奇数序列，其中的2是步长，即数值序列的增量。

a = range(10)
print(a) # range(0, 10)
for x in range(10):
    print(x)
"""
0
1
2
3
4
5
6
7
8
9
"""

for y in range(2, 20, 2):
    print(y)
"""
2
4
6
8
10
12
14
16
18
"""

enumerate

同时遍历下标和元素

index = 0
for index, x in enumerate([1, 2, 3, 4, 5]):
    print(index, x)
"""
0 1
1 2
2 3
3 4
4 5
"""

前100项的和

sum = 0
for n in range(1, 101):
    sum += n
print(sum) # 5050

break 语句

作用：跳出for和while循环
注意：只能跳出距离他最近的那一层循环

for i in range(10):
    print(i)
    if i == 5:
        # 跳出循环
        break

num = 1
while num < 10:
    print(num)
    num += 1
    if num == 3:
        break
else:
    print("Hello World")

continue 语句

作用：跳过当前循环中的剩余语句
注意：跳过距离最近的循环

for i in range(10):
    print(i)
    if i == 3:
        continue
    print("*")
    print("&")

num = 0
while num < 10:
    print(num)
    if num == 3:
        num += 1
        continue
    print("*")
    print("&")
    num += 1

迭代器基础

可迭代对象 : 可以直接作用于for循环的对象统称为可迭代对象、(Iterable) 可以用isinstance()去判断一个对象是否是Iterable对象

可以直接作用于for的数据类型一般分为两种

集合数据类型，如list、tuple、dict、set、string
是generator，包括生成器和带yield的generator function

from collections.abc import Iterable
from collections.abc import Iterator

## 原版是这个 from collections import Iterable 但是会报错

print(isinstance([], Iterable)) # True
print(isinstance((), Iterable)) # True
print(isinstance({}, Iterable)) # True
print(isinstance("", Iterable)) # True
print(isinstance((x for x in range(10)), Iterable)) # True
print(isinstance(1, Iterable)) # False

迭代器：不但可以作用于for循环，还可以被next函数不断调用并返回下一个值，直到最后抛出一个StopIteration错误表示无法继续返回下一个值

可以被next()函数调用并不断返回下一个值的对象称为迭代器(Iterator)

可以使用isinstance()函数判断一个对象是否是Iterator对象

print(isinstance((), Iterator)) # False
print(isinstance({}, Iterator)) # False
print(isinstance("", Iterator)) # False
print(isinstance((x for x in range(10)), Iterator)) # True


l = (x for x in [2, 4, 5, 8, 6])
print(l) # <generator object <genexpr> at 0x00000178428CB840>
print(next(l)) # 2
print(next(l)) # 4
print(next(l)) # 5
print(next(l)) # 8
print(next(l)) # 6


## 转成Iterator对象
a = iter([1, 2, 3, 4, 5])
print(next(a)) # 1
print(next(a)) # 2

print(isinstance(iter([]), Iterator)) # True
print(isinstance(iter(()), Iterator)) # True
print(isinstance(iter({}), Iterator)) # True
print(isinstance(iter(""), Iterator)) # True

案例

iter(func，sentinel)
如果是传递两个参数给 iter() ，它会重复地调用 func ，直到迭代器的下个值等于sentinel

endstr = "end"
str = ""
for line in iter(input, endstr):
    str += line + "\n"
print(str)

函数编程

函数基础

函数概述

函数：就是完成特定功能的代码块
本质：就是对代码的封装
格式：

1
2
3

def 函数名（[参数1],[参数2]....[参数n]）:
	语句
	return 表达式

def：函数代码块以def关键字开始：
函数名：遵循标识符规则

函数的调用

格式：函数名(参数列表)
函数名：是要使用的功能的函数名字
参数列表：函数的调用者给函数传递的信息,如果没有参数，小括号也不能省略

函数调用的本质：实参给形参赋值的过程

# 函数也是一种数据类型
def sum(a, b):
    # pass # 代表空语句
    return a + b

f = sum
aa = f(1, 2)
print(aa) # 3
res = sum(1, 2)
print(res) # 3

函数的参数

函数(无参无返回值)

def myPrint1():
    print("Hello world")
    print("Hello new world")
    print("Hello old world")

myPrint1()

形参(形式参数):定义函数时小括号中的变量，本质是变量
参数必须按顺序传递，个数目前要对应
1
2
def myPrint2(str, age):
print(str, age)
实参(实际参数):调用函数时给函数传递的数据，本质是值
1
myPrint2("Hello world", 18)
函数的返回值

def mySum(num1, num2):
    # 将结果返回给函数的调用者
    return num1 + num2
    # 执行完return语句，该函数就结束了，return后面的代码不执行

sum = mySum(1, 2)
print(sum) # 3

参数传递

值传递：传递不可变类型
string、tuple、number是不可变的

def fun1(num):
    print(id(num)) # 140704961553648
    num = 10
    print(id(num)) # 140704961553648

temp = 20
print(id(temp)) # 140704961553328 
fun1(temp)  # num = temp
print(temp) # 20

引用传递：传递可变类型
list、dict、set是可变的

def fun2(lis):
    lis[0] = 100

li = [1, 2, 3, 4, 5]
fun2(li)
print(li) # [100, 2, 3, 4, 5]

关键字参数

概念:允许函数调用时参数的顺序与定义时不一致

def myPrint(str, age):
    print(str, age)

# 使用关键字参数
myPrint(age=18, str="Hello world") # Hello world 18

默认参数

概念：调用函数时，如果没有传递参数，则使用默认参数

# 如果以后要用默认参数，最好将默认参数放到最后
def myPrint(str, age=18):
    print(str, age)

myPrint("kaige good", 10) # kaige good 10

不定长参数

概念：能处理比定义时更多的参数

*parameter

# *parameter
# 加了星号(*)的变量存放所有未命名变量参数，如果在函数时没有给定参数，它就是一个空元组
def func(name, *args):
    print(name) # sunck
    print(type(args)) # <class 'tuple'>
    for x in args:
        print(x)
	"""
	good
	nice
	handsom
	"""
func("sunck", "good", "nice", "handsom")

def mySum(*l):
    sum = 0
    for i in l:
        sum += i
    return sum

print(mySum(1, 2, 3)) # 6
print(mySum(1, 2, 3, 4, 5, 6)) # 21

**parameter

# **parameter
# **代表键值对的参数字典和*所代表的意义类似
def func2(**kwargs):
    print(kwargs) # {'x': 1, 'y': 2, 'z': 3}
    print(type(kwargs)) # <class 'dict'>

func2(x=1, y=2, z=3)

def func3(*args, **kwargs):
    pass  # 代表一个空语句

匿名函数

概念：不使用def这样的语句定义函数，使用lambda来创建匿名函数

特点：

lambda只是一个表达式，函数体比def简单
lambda的主体是一个表达式，而不是代码块，仅仅只能在lambda表达式中封装简单的逻辑
lambda函数有自己的命名空间，且不能访问自由参数列表之外的或全局命名空间的参数
虽然lambda是一个表达式且看起来只能写一行，与C/C++内联函数不同

格式：lambda 参数1,参数2,……，参数n:expression(表达式)

1 2	sum = lambda num1, num2: num1 + num2 print(sum(1, 2)) # 3

作用域

作用域：变量可以使用的范围

程序的变量并不是在所有位置都使用的，访问的权限决定于变量的在哪里赋值的

作用域： L_E_G_B

局部作用域
函数作用域
全局作用域
内建作用域

nonlocal 用来声明外层的局部变量
global 用来声明全局变量

# 局部作用域
def foo1():
    a = 5
    
foo1()
# print(a)  # NameError
print("-----------------------------局部作用域")

# 全局作用域
b = 10

def foo2():
    print(b)

foo2() # 10
print("-----------------------------全局作用域")

def foo3():
    b = 100  # 局部变量
    print(b)

foo3() # 100
print(b) # 10
print("-----------------------------局部变量")

def foo4():
    global b  # 将b声明为全局变量
    b = 200  # 全局变量
    print(b)

foo4() # 200
print(b) # 200
print("-----------------------------全局变量")

a = 100

def outer():
    b = 10

    def inner():
        nonlocal b  # 声明外部函数的局部变量
        print("inner b:", b) # inner b: 10
        b = 20

        global a  # 将a声明为全局变量
        a = 1000 

    inner()
    print("outer b:", b) # outer b: 20

outer()
print("a:", a) # a: 1000

偏函数

import functools

#
print(int("1010", base=2)) # 10

# 偏函数
def int2(str1, base=2):
    return int(str1, base)

print(int2("1011")) # 11
# 把一个参数固定住，形成一个新的参数
int3 = functools.partial(int, base=2)
print(int3("1011")) # 11

Python是什么

简介

安装

基础知识

注释的使用

print

关键字

变量的使用

input

程序执行过程

变量的定义

数字类型转换

数据类型

string 字符串

创建

字符串运算

字符串连接 拼接

输出重复字符串

索引取值

字符串截取

判断是否存在

格式化输出

转义字符

字符串方法

可变字符串

list 列表

创建列表

创建空列表

创建带有元素的列表

元素可以是其他类型

列表元素的访问

列表操作

列表组合

列表的重复

判断元素是否在列表中

列表截取

二维列表

列表方法

append()

extend()

insert()

pop(x=list[-1])

remove()

clear()

index()

列表中有多少个元素

max()

min()

count()

reverse() 倒序

sort() 排序

拷贝

浅拷贝 引用拷贝

深拷贝 内存拷贝

将元组转成列表

list 去重

列表推导式

zip

tuple 元组

创建空的元组

创建带有元素类型的元组

元组中的元素的类型可以不同

定义只有一个元素的元组

元组元素的访问

元组中的元素不可以修改

删除元组 del

元组的操作

元组重复

判断元素是否在元组中

元组的截取

二维元组 元素为一维元组

元组的方法

len()

max()

min()

将列表转成元组 tuple()

元组的遍历

元组推导式

dict 字典

创建字典

字符串连接拼接

浅拷贝引用拷贝

深拷贝内存拷贝

二维元组元素为一维元组