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

Python是什么

简介

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

安装

这个是我B站的安装教程

基础知识

注释的使用

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

1
2
3
4
5
6
7
# 这是一个单行注释

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

快捷键的使用

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

print

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

1
2
3
4
5
6
7
8
9
10
11
12
13
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

关键字

1
2
3
4
5
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)

程序执行过程

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

1
2
3
4
5
6
7
8
9
10
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

  • 交互式定义变量

    1
    2
    3
    4
    5
    6
    7
    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()：将字符串（一个字符）转换成对应的编码（整数）。

1
2
3
4
5
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"
字符串运算
字符串连接 拼接
1
2
3
4
5
6
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开始
1
2
3
4
5
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
格式化输出
1
2
3
4
5
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 换行

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    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写在一行不好阅读

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    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当成有效的表达式来并返回计算结果

    1
    2
    3
    4
    5
    6
    7
    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()：转换字符串中的小写字母为大写字母

    1
    2
    3
    4
    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()截取字符串左右指定的字符 默认为空格

    1
    2
    3
    4
    5
    6
    7
    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个字符串

    1
    2
    3
    4
    5
    6
    7
    8
    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 会保留换行符

    1
    2
    3
    4
    5
    6
    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个

    1
    2
    3
    4
    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!

  • 创建一个字符串映射表

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

    1
    2
    3
    4
    5
    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凯!"

    1. 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'>

    2. 解码

      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

    1
    2
    3
    4
    5
    print("ABC".isupper()) # True
    print("1".isupper()) # False
    print("c".isupper()) # False
    print("ABC1".isupper()) # True
    print("ABC#".isupper()) # True

  • islower()

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

    1
    2
    3
    4
    5
    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

    1
    2
    3
    4
    5
    6
    print(" ".isspace()) # True
    print("      ".isspace()) # True
    print("\t".isspace()) # True
    print("\n".isspace()) # True
    print("\r".isspace()) # True
    print("\f".isspace())  True
可变字符串
1
2
3
4
5
6
7
8
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 = []
创建带有元素的列表
1
2
3
4
5
6
7
8
9
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]
列表操作
列表组合
1
2
3
4
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
列表截取
1
2
3
4
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()

在列表末尾添加一个元素

1
2
3
4
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()

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

1
2
3
4
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])

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

1
2
3
4
5
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()

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

1
2
3
4
5
6
7
8
9
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]
拷贝
浅拷贝 引用拷贝
1
2
3
4
5
6
7
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
深拷贝 内存拷贝
1
2
3
4
5
6
7
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

案例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
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
2
3
4
5
6
7
8
## 1
## s = set(l)
## l = list(s)
## print(l)

## 2
l = list(set(l))
print(l) # [1, 2, 3, 4, 5, 6]
列表推导式
1
2
3
4
5
6
7
8
9
10
11
"""
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对象

1
2
3
4
5
6
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开始

取值

1
2
3
4
5
6
7
8
9
10
11
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
元组中的元素不可以修改
1
2
3
4
5
6
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)
元组的操作
1
2
3
4
5
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
元组的截取

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

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

1
2
3
4
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)
元组的遍历
1
2
3
4
5
6
7
8
9
for x in (1, 2, 3, 4, 5):
    print(x)
"""
1
2
3
4
5
"""
元组推导式
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
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的特性：

  1. 字典中的key必须唯一
  2. key必须是不可变对象
  3. 字符串、整数等都是不可变的，可以作为key
  4. 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()创建字典对象
1
2
3
4
k = ['name','age','job']
v = ['haha',18,'player']
d = dict(zip(k,v))
print(d) # {'name': 'haha', 'age': 18, 'job': 'player'}
元素的访问
获取

字典名[key] 或 get

1
2
3
4
5
6
7
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}
遍历
1
2
3
4
5
6
7
8
9
10
11
12
13
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合并
1
2
3
4
5
6
7
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比较

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

list

  1. 查找和插入会随着数据量的增加而变慢
  2. 占用空间小，浪费内存少
1
2
3
4
5
6
7
8
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中会自动被过滤

1
2
3
4
5
6
7
8
9
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}
添加
1
2
3
4
5
6
7
8
9
10
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 字符串 打碎插入

1
2
3
4
5
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}
遍历
1
2
3
4
5
6
7
8
9
10
s7 = set([1, 2, 3, 4, 5])
for i in s7:
    print(i)
"""
1
2
3
4
5
"""

set没有索引

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

enumerate

1
2
3
4
5
6
7
8
9
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

数据类型的类型转换

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
## 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
2
3
4
5
+   -   *   /   %     **     //
加 减  乘  除  取摸  求幂  取整

算数运算表达式
1 + 1  2 * 3  a /3
1
2
3
4
5
6
7
8
9
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

复合运算符

1
2
3
4
5
6
7
8
9
+=   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
1
2
3
4
5
6
7
print(5 & 7) # 5
"""
101
111
---
101
"""
按位或

  • | 按位或运算符

  • 有一个位数为1 结果为1 否则为0

1
2
3
4
5
6
7
print(5 | 7) # 7
"""
101
111
---
111
"""
按位异或
  • ^ 按位异或运算符
  • 二进制两位相异是结果为1
1
2
3
4
5
6
7
print(5 ^ 7) # 2
"""
101
111
---
010
"""
位取反
  • ~ 按位取反运算符
  • 每个二进制数据位取反，1变0，0变1
1
2
3
4
5
6
print(~5) # -6
"""
00000101
11111010
10000110
"""

左移运算符

  • << 左移运算符

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

1
2
3
4
5
print(2 << 2) # 
"""
00000010    2
00001000    8
"""

右移运算符

  • >> 右移运算符
  • 各二进制位右移动若干位 由>>右侧数字决定
1
2
3
4
5
print(2 >> 2) # 0
"""
00000010    2
00000000    0
"""

关系运算符

1
2
3
4
5
关系运算符 
 ==     ！=      >       <       >=      <=   

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

逻辑运算符

逻辑与 and
  • 逻辑与运算表达式 表达式1 and 表达式2
  • 有一个为假就为假
1
2
3
4
5
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
  • 有一个为真就为真
1
2
3
4
5
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 判断两个标识符是不是引用不同的对象

运算符优先级

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
**
~ + -(正负号[一元加减])

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

条件控制语句

if 语句

1
2
3
4
5
6
7
8
9
10
11
12
13
14
if 语句
格式：
if 表达式:
    语句

if else 语句
格式：
if 表达式:
    语句1
else:
    语句2
    
如何为假？
假： 0    0.0    ''   None    False 
1
2
3
4
5
6
7
8
num5 = 20
num6 = 20

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

if-else

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
    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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
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 语句

1
2
3
4
while 语句：

while 表达式：
    语句
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
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")
1
2
3
4
5
6
while  else 语句：

while 表达式：
    语句1
else:
    语句2
1
2
3
4
5
6
a = 1
while a <= 3:
    print("hello world")
    a += 1
else:
    print("very very good")

for 语句

1
2
3
4
for 语句
格式：
for 变量名 in 集合:
    语句
1
2
3
4
5
6
7
8
9
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是步长，即数值序列的增量。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
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

同时遍历下标和元素

1
2
3
4
5
6
7
8
9
10
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项的和
1
2
3
4
sum = 0
for n in range(1, 101):
    sum += n
print(sum) # 5050

break 语句

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
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 语句

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
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的数据类型一般分为两种

  1. 集合数据类型，如list、tuple、dict、set、string
  2. 是generator，包括生成器和带yield的generator function
1
2
3
4
5
6
7
8
9
10
11
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对象

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
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
    1
    2
    3
    4
    5
    endstr = "end"
    str = ""
    for line in iter(input, endstr):
        str += line + "\n"
    print(str)

函数编程

函数基础

函数概述

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

1
2
3
def 函数名（[参数1],[参数2]....[参数n]）:
	语句
	return 表达式
  • def：函数代码块以def关键字开始：
  • 函数名：遵循标识符规则

函数的调用

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

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

1
2
3
4
5
6
7
8
9
10
# 函数也是一种数据类型
def sum(a, b):
    # pass # 代表空语句
    return a + b

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

函数的参数

  • 函数(无参无返回值)

    1
    2
    3
    4
    5
    6
    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)

函数的返回值

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

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

参数传递

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

1
2
3
4
5
6
7
8
9
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是可变的

1
2
3
4
5
6
def fun2(lis):
    lis[0] = 100

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

关键字参数

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

1
2
3
4
5
def myPrint(str, age):
    print(str, age)

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

默认参数

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

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

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

不定长参数

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

*parameter

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
# *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

1
2
3
4
5
6
7
8
9
10
# **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来创建匿名函数

特点：

  1. lambda只是一个表达式，函数体比def简单
  2. lambda的主体是一个表达式，而不是代码块，仅仅只能在lambda表达式中封装简单的逻辑
  3. lambda函数有自己的命名空间，且不能访问自由参数列表之外的或全局命名空间的参数
  4. 虽然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 用来声明全局变量
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
# 局部作用域
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

偏函数

1
2
3
4
5
6
7
8
9
10
11
12
13
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

高阶函数