标题完全是用来凑字数的

所谓错过，不是错了，而是过了。

慢慢总结自己的一些经验，熟稔于心，每日诵读烙印于心，就好像Python的装饰器一般，每次做事之前过一遍经验，希望以后变成越来越优秀的人。

python简略知识概要-by ggxiaoyuboy

一、基础语法   

1 变量及其命名规则

变量是存储在内存中的值，这就意味着在创建变量时会在内存中开辟一个空间。

• 有字母数字下划线组成，不以数字开头

• 不允许使用关键字

• 区分大小写

• 见名知意

2关键字

['False', 'None', 'True', 'and', 'as', 'assert', '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']

3 注释

Python 中单行注释使用 #，多行注释使用三个单引号（'''）或 三个双引号（"""）

注释的作用：在程序中对某些代码进行标注说明，增强程序的可读性。

# 单行注释 （为了保证代码的可读性，`#` 后面建议先添加一个空格，然后再编写相应的说明文字）
​
'''
多行注释
多行注释
'''
​
"""
多行注释
多行注释
"""
​

4 多行语句

Python 通常是一行写完一条语句，但如果语句很长，我们可以使用反斜杠 \ 来实现多行语句，例如：

a = b + \
    c + \
    d   
# 等价于
a = b + c + d
​

在 [], {}, () 中的多行语句，不需要使用反斜杠 \，例如：

temp = ['a', 'b', 'c',
        'd', 'e']

5 print 输出

print 默认输出是换行的，如果要实现不换行需要在变量末尾加上 end=""：

a = 1
b = 2
print(a)
print(b)
 
print('---------')
# 不换行输出
print(a, end=" " )
print(b, end=" " )

输出结果如下：

1
2        
---------
1 2 

二、六大数据类型（只详细介绍五种）

1 六大数据类型

Number（数字） String（字符串） Tuple（元组） List（列表） Dictionary（字典） Set（集合） 不可变数据（3 个）：Number（数字）、String（字符串）、Tuple（元组） 可变数据（3 个）：List（列表）、Dictionary（字典）、Set（集合）

2 Number（数字）

三种不同的数值类型：

int(整型) ：通常被称为是整型或整数，是正或负整数，不带小数点。布尔(bool)是整型的子类型。（true:1 false:0） float(浮点型)：浮点型由整数部分与小数部分组成，浮点型也可以使用科学计数法表示（2.5e2 = 2.5 x 100 = 250） complex(复数)：复数由实数部分和虚数部分构成，可以用a + bj,或者complex(a,b)表示， 复数的实部a和虚部b都是浮点型 数字类型转换(只有能转的才行，string绝对不可以哟（手动狗头）)：

int(x)：将x转换为一个整数。 float(x)：将x转换到一个浮点数。 complex(x)：将x转换到一个复数，实数部分为 x，虚数部分为 0。 complex(x, y)：将 x 和 y 转换到一个复数，实数部分为 x，虚数部分为 y。x 和 y 是数字表达式

常用数学函数：

abs(x)	返回数字的绝对值，如abs(-10) 返回 10
ceil(x)	返回数字的上入整数，如math.ceil(4.1) 返回 5
max(x,y,z........)	返回给定参数的最大值，参数可以为序列。
min(x1, x2,…)	返回给定参数的最小值，参数可以为序列。
pow(x,y)	x**y 运算后的值。
round(x [,n])	回浮点数 x 的四舍五入值，如给出 n 值，则代表舍入到小数点后的位数。
floor(x)	返回数字的下舍整数，如math.floor(4.9)返回 4

（这里我偷下懒，自己去运行下）

3 String（字符串）

Python中的字符串用单引号 ' 或双引号 " 括起来，同时使用反斜杠 \ 转义特殊字符。

1、常用字符串运算符：

操作符	描述	实例
+	字符串连接	a + b 输出结果： ab
*	重复输出字符串	a*2 输出结果：aa
[]	通过索引获取字符串中字符	a=‘Hello’，a[1] 输出结果：e
[:]	截取字符串中的一部分，遵循左闭右开原则，str[0:2] 是不包含第 3 个字符的	a=‘Hello’，a[1:4] 输出结果 ell
in	成员运算符 - 如果字符串中包含给定的字符返回 True	‘H’ in Hello 输出结果 True
not in	成员运算符 - 如果字符串中不包含给定的字符返回 True	‘M’ not in Hello 输出结果 True

2、字符串格式化：

#常见语法：f'{表达式}'
name="GGBond"
age="20"
print(f'我的名字是：{name},我的年龄是：{age}') # 我的名字是：GGBond,我的年龄是：20

3、类型判断

方法	说明
string.isalpha()	如果 string 至少有一个字符并且所有字符都是字母则返回 True
string.isdecimal()	如果 string 只包含数字则返回 True
string.isdigit()	如果 string 只包含数字则返回 True
string.isnumeric()	如果 string 只包含数字则返回 True

4、大小写转换

方法	说明
string.capitalize()	把字符串的第一个字符大写
string.title()	把字符串的每个单词首字母大写
string.lower()	转换 string 中所有大写字符为小写
string.upper()	转换 string 中的小写字母为大写去除空白字符

5、去除空白字符

方法	说明
string.lstrip()	截掉 string 左边（开始）的空白字符
string.rstrip()	截掉 string 右边（末尾）的空白字符
string.strip()	截掉 string 左右两边的空白字符

6、拆分和连接

方法	说明
string.split(str=“”, num)	以 str 为分隔符拆分 string，如果 num 有指定值，则仅分隔 num + 1 个子字符串，str 默认包含 ‘\r’, ‘\t’, ‘\n’ 和空格
string.join(seq)	以 string 作为分隔符，将 seq 中所有的元素（的字符串表示）合并为一个新的字符串索引的顺序和倒序

7、字符串的切片

切片 方法适用于 字符串、列表、元组切片使用索引值来限定范围，从一个大的字符串中切出小的 字符串 列表 和 元组 都是 有序 的集合，都能够 通过索引值 获取到对应的数据 字符串[开始索引:结束索引:步长] 注意：

1、指定的区间属于左闭右开型 [开始索引, 结束索引) => 开始索引 >= 范围 < 结束索引

• 从 起始 位开始，到 结束位的前一位 结束（不包含结束位本身)

2、从头开始，开始索引数字可以省略，冒号不能省略

3、到末尾结束，结束索引数字可以省略，冒号不能省略

4、步长默认为 1，如果连续切片，数字和冒号都可以省略

索引的顺序和倒序

• 在 Python 中不仅支持顺序索引，同时还支持倒序索引

• 所谓倒序索引就是从右向左计算索引

  • 最右边的索引值是 -1，依次递减。

小小的demo

num_str = "0123456789"
​
# 1. 截取从 2 ~ 5 位置 的字符串
print(num_str[2:6])
​
# 2. 截取从 2 ~ `末尾` 的字符串
print(num_str[2:])
​
# 3. 截取从 `开始` ~ 5 位置 的字符串
print(num_str[:6])
​
# 4. 截取完整的字符串
print(num_str[:])
​
# 5. 从开始位置，每隔一个字符截取字符串
print(num_str[::2])
​
# 6. 从索引 1 开始，每隔一个取一个
print(num_str[1::2])
​
# 倒序切片
# -1 表示倒数第一个字符
print(num_str[-1])
​
# 7. 截取从 2 ~ `末尾 - 1` 的字符串
print(num_str[2:-1])
​
# 8. 截取字符串末尾两个字符
print(num_str[-2:])
​
# 9. 字符串的逆序
print(num_str[::-1])

4 Tuple（元组）

元组创建很简单，只需要在括号()中添加元素，并使用逗号隔开即可，并且元组中的元素不能改变！(可被遍历)

tup1 = ('hello', 'world', 1, 2)
print(tup1) # ('hello', 'world', 1, 2)
print(type(tup1)) # <class 'tuple'>

常用运算符：

操作符	描述	实例
len（）	计算元素个数	len(tup1)，输出结果：4
+	连接	tup1 + (3,4)，输出结果：(‘hello’, ‘world’, 1, 2, 3, 4)
*	复制	(‘Hi!’,) * 4 ，输出结果：(‘Hi!’, ‘Hi!’, ‘Hi!’, ‘Hi!’)
in	元素是否存在	3 in (1, 2, 3)，输出结果：True
[]	读取第几个元素	（“hello”,"world"）[0]，输出结果：hello
[:]	截取字符串的一部分	[0:2]，输出结果：(‘hello’, ‘world’)

5 List（列表）

列表是写在方括号 [] 之间、用逗号分隔开的元素列表。列表中元素的类型可以不相同，它支持数字，字符串甚至可以包含列表（所谓嵌套）。列表中的元素是可以改变滴。

a = [1, 2, 3, 4, 5]
# 下表索引的方式修改
a[0] = 9
print(a) # [9, 2, 3, 4, 5]
​
# append()方法：追加列表
a.append(6)
print(a) # [9, 2, 3, 4, 5, 6] 
​
# del 语句来删除列表的的元素
del a[0]
print(a) # [2, 3, 4, 5, 6]  

常用函数（给你们上一张抽象又生动的截图）

6、Set（集合）

集合可以使用大括号 {} 或者 set() 函数创建集合，注意：创建一个空集合必须用 set() 而不是 { }，因为 { } 是用来创建一个空字典。集合是一个无序的不重复元素序列，集合内的元素可以改变。

两种创建格式：

set1 = {'GGBond',20,20}
print(set1) # {'GGBond', 20} ；元素不重复只显示一个20
​
set2 = set('abcd')
print(set2) # {'c', 'b', 'd', 'a'} ; 元素没有顺序

修改集合：

set1 = {'GGBond',20,20}
​
#add()：添加方法
set1.add('猪猪侠')
print(set1) # {'猪猪侠', 'GGBone', 20}
​
# update()：也可以添加元素，且参数可以是列表，元组，字典等
set1.update([1,2],[3,4])
print(set1) # {1, '猪猪侠', 2, 3, 4, 20, 'GGBond'}
​
# remove()：移除元素
set1.remove('猪猪侠')
print(set1) # {1, 2, 3, 4, 20, 'GGBond'}

遍历集合：

set1 = {'猪猪侠',20,20}
​
for i in set1:
    print(i,end=" ")
# 20 猪猪侠

7、dict（字典）

字典的每个键值 key=>value 对用冒号 : 分割，每个对之间用逗号(,)分割，整个字典包括在花括号 {} 中 ,格式如下所示：

d = {key1 : value1, key2 : value2, key3 : value3 }
1
键必须是唯一的，但值则不必。值可以取任何数据类型。

访问字典的值：

dict = {'Name': 'GGbond', 'Age': 22}
print(dict) # {'Name': 'GGbond', 'Age': 22}

print (dict['Name']) # GGbond
print (dict['Age']) # 22

修改字典：

dict = {'Name': 'GGbond', 'Age': 22}

dict['Name'] = '小宇'
dict['Age'] = 20

print(dict) # {'Name': '小宇', 'Age': 20}

遍历字典：

dict = {'Name': 'GGbond', 'Age': 20}

#遍历键
for key in dict.keys():
    print(key)
"""
Name
Age
"""

# 遍历值

for value in dict.values():
    print(value)
"""
GGbond
20
"""

8、总结

其实字符串、列表、元组、集合之间有相同点和不同点。但是以上我已经整的够详细了。你们自己总结吧，我肝不动了。

9 数据类型转换函数

前置知识：type（）函数查看数据类型。

int()

将float、bool、str类型的数据转换为int类型。float类型转换为int类型时去除小数点后面的数；bool类型转换为int类型时False变为0、True变为1；str类型直接转换为int类型

案例：

# 定义float变量
f = 9.99
# 定义bool类型变量
b1 = False
b2 = True
# 定义str类型变量
s = '111'
​
# 使用int()函数
int1 = int(f)
int2 = int(b1)
int3 = int(b2)
int4 = int(s)
​
print("int1:",int1) 
print("int1的类型是：",type(int1))
print("-"*10)
​
print("int2:",int2)
print("int2的类型是：",type(int2))
print("int3:",int3)
print("int3的类型是：",type(int3))
print("-"*10)
​
print("int3:",int4)
print("int3的类型是：",type(int4))
​
'''
int1: 9
int1的类型是： <class 'int'>
----------
int2: 0
int2的类型是： <class 'int'>
int3: 1
int3的类型是： <class 'int'>
----------
int3: 111
int3的类型是： <class 'int'>
'''

bool()

将int、float、str类型的数据转换为bool类型。int类型转换为bool类型时0变为False、其他数据变为True；float类型转换为bool时0.0变为False、其他数据变为True；str类型转换为bool类型时不存在数据变为False、存在数据变为True。

案例：

# 定义int变量
i1 = 0
i2 = -1
i3 = 1
# 定义float变量
f1 = 0.0
f2 = -1.0
f3 = 1.0
# 定义str变量
s1 = ''
s2 = '0'
s3 = '-1'
s4 = '1'
s5 = 'A'
​
# 使用bool()函数
b1 = bool(i1)
b2 = bool(i2)
b3 = bool(i3)
b4 = bool(f1)
b5 = bool(f2)
b6 = bool(f3)
b7 = bool(s1)
b8 = bool(s2)
b9 = bool(s3)
b10 = bool(s4)
b11 = bool(s5)
​
print("b1:",b1) 
print("b1的类型是：",type(b1))
print("b2:",b2) 
print("b2的类型是：",type(b2))
print("b3:",b3) 
print("b3的类型是：",type(b3))
print("-"*10)
​
print("b4:",b4) 
print("b4的类型是：",type(b4))
print("b5:",b5) 
print("b5的类型是：",type(b5))
print("b6:",b6) 
print("b6的类型是：",type(b6))
print("-"*10)
​
print("b7:",b7) 
print("b7的类型是：",type(b7))
print("b8:",b8) 
print("b8的类型是：",type(b8))
print("b9:",b9) 
print("b9的类型是：",type(b9))
print("b10:",b10) 
print("b10的类型是：",type(b10))
print("b11:",b11) 
print("b11的类型是：",type(b11))
​
'''
b1: False
b1的类型是： <class 'bool'>
b2: True
b2的类型是： <class 'bool'>
b3: True
b3的类型是： <class 'bool'>
----------
b4: False
b4的类型是： <class 'bool'>
b5: True
b5的类型是： <class 'bool'>
b6: True
b6的类型是： <class 'bool'>
----------
b7: False
b7的类型是： <class 'bool'>
b8: True
b8的类型是： <class 'bool'>
b9: True
b9的类型是： <class 'bool'>
b10: True
b10的类型是： <class 'bool'>
b11: True
b11的类型是： <class 'bool'>
'''

float()

将int、bool、str类型的数据转换为float类型数据。int类型转换为float时在末尾添加小数位；bool类型转换为float时False变为0.0,、True变为1.0；str类型直接转换为float类型。

案例：

# 定义int变量
i1 = 1
i2 = -1
# 定义bool变量
b1 = False
b2 = True
# 定义str变量
s1 = '99'
​
# 使用float()函数
f1 = float(i1)
f2 = float(i2)
f3 = float(b1)
f4 = float(b2)
f5 = float(s1)
​
print("f1:",f1) 
print("f1的类型是：",type(f1))
print("f2:",f2) 
print("f2的类型是：",type(f2))
print("-"*10)
​
print("f3:",f3) 
print("f3的类型是：",type(f3))
print("f4:",f4) 
print("f4的类型是：",type(f4))
print("-"*10)
​
print("f5:",f5) 
print("f5的类型是：",type(f5))
​
'''
f1: 1.0
f1的类型是： <class 'float'>
f2: -1.0
f2的类型是： <class 'float'>
----------
f3: 0.0
f3的类型是： <class 'float'>
f4: 1.0
f4的类型是： <class 'float'>
----------
f5: 99.0
f5的类型是： <class 'float'>
'''

str()

将int、float、bool、list、tuple、set、dict类型的数据转换为str类型

案例：

# 定义int类型变量
i1 = 1
# 定义float类型变量
f1 = 9.99
# 定义bool类型变量
b1 = False
b2 = True
# 定义list类型变量
l1 = [1, 2, 'a', 'b']
# 定义tuple类型变量
t1 = (1, 2, 'a', 'b')
# 定义set类型变量
s1 = {1, 2, 'a', 'b'}
# 定义dict类型变量
d1 = {'name': '猪猪侠', 'age':18}
​
# 使用str()函数
str1 = str(i1)
str2 = str(f1)
str3 = str(b1)
str4 = str(b2)
str5 = str(l1)
str6 = str(t1)
str7 = str(s1)
str8 = str(d1)
​
print("str1:",str1) 
print("str1的类型是：",type(str1))
print("-"*10)
​
print("str2:",str2) 
print("str2的类型是：",type(str2))
print("-"*10)
​
print("str3:",str3) 
print("str3的类型是：",type(str3))
print("str4:",str4) 
print("str4的类型是：",type(str4))
print("-"*10)
​
print("str5:",str5) 
print("str5的类型是：",type(str5))
print("-"*10)
​
print("str6:",str6) 
print("str6的类型是：",type(str6))
print("-"*10)
​
print("str7:",str7) 
print("str7的类型是：",type(str7))
print("-"*10)
​
print("str8:",str8) 
print("str8的类型是：",type(str8))
​
'''
str1: 1
str1的类型是： <class 'str'>
----------
str2: 9.99
str2的类型是： <class 'str'>
----------
str3: False
str3的类型是： <class 'str'>
str4: True
str4的类型是： <class 'str'>
----------
str5: [1, 2, 'a', 'b']
str5的类型是： <class 'str'>
----------
str6: (1, 2, 'a', 'b')
str6的类型是： <class 'str'>
----------
str7: {'b', 1, 2, 'a'}
str7的类型是： <class 'str'>
----------
str8: {'name': '猪猪侠', 'age': 18}
str8的类型是： <class 'str'>
'''

list()

将tuple、set、dict类型的数据转换为list类型。其中dict类型转换为list类型时，获取的列表中存储的值是dict类型变量的key值。

案例：

# 定义tuple变量
t1 = (1, 2, 'a', 'b')
# 定义set变量
s1 = {1, 2, 'a', 'b'}
# 定义dict变量
d1 = {'name': '猪猪侠', 'age':18}
​
# 使用list()函数
l1 = list(t1)
l2 = list(s1)
l3 = list(d1)
​
print("l1:",l1) 
print("l1的类型是：",type(l1))
print("-"*10)
​
print("l2:",l2) 
print("l2的类型是：",type(l2))
print("-"*10)
​
print("l3:",l3) 
print("l3的类型是：",type(l3))
​
'''
l1: [1, 2, 'a', 'b']
l1的类型是： <class 'list'>
----------
l2: [1, 2, 'b', 'a']
l2的类型是： <class 'list'>
----------
l3: ['name', 'age']
l3的类型是： <class 'list'>
'''

tuple()

将list、set、dict类型的数据转换为tuple类型。其中dict类型转换为tuple类型时获取的元祖中存储的值是dict类型变量的key值。

案例：

# 定义list变量
l1 = [1, 2, 'a', 'b']
# 定义set变量
s1 = {1, 2, 'a', 'b'}
# 定义dict变量
d1 = {'name': '猪猪侠', 'age':18}
​
# 使用tuple()函数
t1 = tuple(l1)
t2 = tuple(s1)
t3 = tuple(d1)
​
print("t1:",t1) 
print("l1的类型是：",type(t1))
print("-"*10)
​
print("t2:",t2) 
print("t2的类型是：",type(t2))
print("-"*10)
​
print("t3:",t3) 
print("t3的类型是：",type(t3))
​
'''
t1: (1, 2, 'a', 'b')
l1的类型是： <class 'tuple'>
----------
t2: (1, 2, 'b', 'a')
t2的类型是： <class 'tuple'>
----------
t3: ('name', 'age')
t3的类型是： <class 'tuple'>
'''

set()

将list、tuple、dict类型的数据转换为set类型。其中dict类型转换为set类型时获取的元祖中存储的值是dict类型变量的key值。

案例：

# 定义list变量
l1 = [1, 2, 'a', 'b']
# 定义tuple变量
t1 = (1, 2, 'a', 'b')
# 定义dict变量
d1 = {'name': '猪猪侠', 'age':18}
​
# 使用set()函数
s1 = set(l1)
s2 = set(t1)
s3 = set(d1)
​
print("s1:",s1) 
print("s1的类型是：",type(s1))
print("-"*10)
​
print("s2:",s2) 
print("s2的类型是：",type(s2))
print("-"*10)
​
print("s3:",s3) 
print("s3的类型是：",type(s3))
​
'''
s1: {1, 2, 'b', 'a'}
s1的类型是： <class 'set'>
----------
s2: {1, 2, 'b', 'a'}
s2的类型是： <class 'set'>
----------
s3: {'age', 'name'}
s3的类型是： <class 'set'>
'''

dict()

因为dict字典类型是键值对对应，所以list、tuple、set类型没法转换

# 创建空的字典
d1 = dict()
print("d1:",d1)
print("d1的类型是:",type(d1))

'''
d1: {}
d1的类型是: <class 'dict'>
'''

三、运算符

1 算数运算符

• 是完成基本的算术运算使用的符号，用来处理四则运算

运算符	描述	实例
+	加	10 + 20 = 30
-	减	10 - 20 = -10
*	乘	10 * 20 = 200
/	除	10 / 20 = 0.5
//	取整除	返回除法的整数部分（商） 9 // 2 输出结果 4
%	取余数	返回除法的余数 9 % 2 = 1
**	幂	又称次方、乘方，2 ** 3 = 8

• 在 Python 中 * 运算符还可以用于字符串，计算结果就是字符串重复指定次数的结果

2 比较（关系）运算符

运算符 描述

<	检查左操作数的值是否 小于 右操作数的值，如果是，则条件成立，返回 True
>=	检查左操作数的值是否 大于或等于 右操作数的值，如果是，则条件成立，返回 True
==	检查两个操作数的值是否 相等，如果是，则条件成立，返回 True
!=	检查两个操作数的值是否 不相等，如果是，则条件成立，返回 True
<=	参考>=

3 逻辑运算符

运算符	逻辑表达式	描述
and	x and y	只有 x 和 y 的值都为 True，才会返回 True 否则只要 x 或者 y 有一个值为 False，就返回 False
or	x or y	只要 x 或者 y 有一个值为 True，就返回 True 只有 x 和 y 的值都为 False，才会返回 False
not	not y	如果 x 为 True，返回 False 如果 x 为 False，返回 True

4 赋值运算符

• 在 Python 中，使用 = 可以给变量赋值

• 在算术运算时，为了简化代码的编写，Python 还提供了一系列的 与 算术运算符 对应的 赋值运算符

• 注意：赋值运算符中间不能使用空格

运算符 描述 实例 = 简单的赋值运算符 c = a + b 将 a + b 的运算结果赋值为 c += 加法赋值运算符 c += a 等效于 c = c + a -= 减法赋值运算符 c -= a 等效于 c = c - a *= 乘法赋值运算符 c *= a 等效于 c = c * a /= 除法赋值运算符 c /= a 等效于 c = c / a //= 取整除赋值运算符 c //= a 等效于 c = c // a %= 取 模 (余数)赋值运算符 c %= a 等效于 c = c % a 幂赋值运算符 (软件问题，打不出来，你们自己翻书看吧)

5 运算符的优先级

• 以下表格的算数优先级由高到最低顺序排列

运算符	描述
**	幂 (最高优先级)
* / % //	乘、除、取余数、取整除
+ -	加法、减法
<= < > >=	比较运算符
== !=	等于运算符
not and or	逻辑运算符
= %= /= //= -= += *= **=	赋值运算符

四、基础语句

1 条件语句（if、elif、else）

格式：

if 判断条件1:
    执行语句1...
elif 判断条件2:
    执行语句2...
elif 判断条件3:
    执行语句3...
else:
    执行语句4...

成绩等级判断（直接上代码，一看就懂）：

number = int(input("请输入你的成绩: "))
if number >= 90:
    print("优秀")
elif number >= 80:
    print("良好")
elif number >= 70:
    print("不错")
elif number >= 60:
    print("及格")
else:
    print("不及格")

2 循环语句（while）

格式：

while 判断条件(condition)：
    执行语句...

1-100求和

# 1.编写循环 确定 要计算的数字
# 2. 添加 结果  变量，在循环内部 处理计算结果
i = 0
while i <= 100:
    print(i)
    i += 1
​
# 最终代码如下
i = 0
sum = 0
while i <= 100:
    sum += i
    i += 1
print(sum)

死循环（表达式条件永远为true）：

while True: 
   num = int(input("输入一个数字  :"))
   print ("你输入的数字是: ", num)
​
'''
输入一个数字  :10
你输入的数字是:  10
输入一个数字  :50
你输入的数字是:  50
输入一个数字  :
'''

3 循环语句（for）

for 循环可以遍历任何可迭代对象，如一个列表或者一个字符串

格式如下：

# <variable>：存储元素的变量 ；<sequence>：遍历的对象
for <variable> in <sequence>:
    执行语句

案例：

lists = ['GGBond',20,'童话世界']
for i in lists:
    print(i,end=" ")
# GGBond 20 童话世界

range()函数

# 案例1：
for i in range(5):
    print(i,end=" ")
# 0 1 2 3 4 
​
# 案例2（增加步长，如数字3）：
for i in range(0, 10, 3) :
    print(i,end=" ")
# 0 3 6 9 

4 break、continue语句**

break：可以跳出 for 和 while 的循环体。如果你从 for 或 while 循环中终止，任何对应的循环 else 块将不执行。 continue：跳过当前循环块中的剩余语句，然后继续进行下一轮循环。

for循环案例

# for循环中使用break
for i in range(1,10):
    if i%2 == 0:
        break
    print(i,end=" ")
# 输出结果：1，因为2对2取余等于0就结束循环了
​
# for循环中使用continue
for i in range(1,10):
    if i%2 == 0:
        continue
    print(i,end=" ")
# 输出结果：1 3 5 7 9 ，跳过了偶数

while循环案例：

# while循环中使用break
n = 5
while n > 0:
    n -= 1
    if n == 2:
        break
    print(n,end=" ")
# 输出结果：4 3，当n=2时结束循环不输出
​
# while循环中使用continue
n = 5
while n > 0:
    n -= 1
    if n == 2:
        continue
    print(n,end=" ")
# 输出结果：4 3 1 0 ，当n=2时就跳过继续下一次循环

五、函数

1 函数介绍

所谓函数，就是把 具有独立功能的代码块 组织为一个小模块，在需要的时候 调用 函数的使用包含两个步骤：

• 定义函数 —— 封装 独立的功能

• 调用函数 —— 享受 封装 的成果

函数的作用，在开发程序时，使用函数可以提高编写的效率以及代码的 重用

2、函数基本使用

2.1 函数的定义

定义函数的格式如下：

def 函数名():
​
    函数封装的代码
    ……
​

1、def 是英文 define 的缩写 2、函数名称 应该能够表达 函数封装代码 的功能，方便后续的调用 3、函数名称 的命名应该 符合 标识符的命名规则

• 可以由 字母、下划线 和 数字 组成

• 不能以数字开头

• 不能与关键字重名

2.2 函数调用

调用函数很简单的，通过 函数名() 即可完成对函数的调用

2.3 第一个函数练习

需求：

1. 编写一个打招呼 say_hello 的函数，封装三行打招呼的代码

2. 在函数下方调用打招呼的代码

name = "GGBond"
​
# 解释器知道这里定义了一个函数
def say_hello():
    print("hello 1")
    print("hello 2")
    print("hello 3")
​
print(name)
# 只有在调用函数时，之前定义的函数才会被执行
# 函数执行完成之后，会重新回到之前的程序中，继续执行后续的代码
say_hello()
​
print(name)
​

• 定义好函数之后，只表示这个函数封装了一段代码而已

• 如果不主动调用函数，函数是不会主动执行的

3. 函数的参数

练习需求：

1. 开发一个 sum_2_num 的函数

2. 函数能够实现 两个数字的求和 功能

代码如下

def sum_2_num():
​
    num1 = 10
    num2 = 20
    result = num1 + num2
​
    print("%d + %d = %d" % (num1, num2, result))
​
sum_2_num()
​

思考一下函数只能处理 固定数值 的相加吗？

如何解决？

• 如果能够把需要计算的数字，在调用函数时，传递到函数内部就好了！

3.1 函数参数的使用

• 在函数名的后面的小括号内部填写 参数

• 多个参数之间使用 , 分隔

def sum_2_num(num1, num2):
​
    result = num1 + num2
    
    print(f"{num1} + {num2} = {result}" )
​
sum_2_num(50, 20)
​

3.2 形参和实参

• 形参：定义 函数时，小括号中的参数，是用来接收参数用的，在函数内部 作为变量使用

• 实参：调用 函数时，小括号中的参数，是用来把数据传递到 函数内部 用的

翻译一下：以上面那个函数举例：num1，num2是形参，传过去的50，20是实参

4、函数的返回值

• 在写程序中，有时候，会希望 一个函数执行结束后，告诉调用者一个结果，以便调用者针对具体的结果做后续的处理

• 返回值 是函数 完成工作后，最后 给调用者的 一个结果

• 在函数中使用 return 关键字可以返回结果

• 调用函数一方，可以 使用变量 来 接收 函数的返回结果

注意：return 表示返回，后续的代码都不会被执行

eg:

六、局部变量和全局变量

• 局部变量 是在 函数内部 定义的变量，只能在函数内部使用

• 全局变量 是在 函数外部定义 的变量（没有定义在某一个函数内），所有函数 内部 都可以使用这个变量

1 局部变量

• 局部变量 是在 函数内部 定义的变量，只能在函数内部使用

• 函数执行结束后，函数内部的局部变量，会被系统回收

• 不同的函数，可以定义相同的名字的局部变量，但是 彼此之间 不会产生影响

局部变量的作用

• 在函数内部使用，临时 保存 函数内部需要使用的数据

def demo1():
​
    num = 10
​
    print(num)
​
    num = 20
​
    print("修改后 %d" % num)
​
​
def demo2():
​
    num = 100
​
    print(num)
​
demo1()
demo2()
​
print("over")
​
​

2 全局变量

• 全局变量 是在 函数外部定义 的变量，所有函数内部都可以使用这个变量

# 定义一个全局变量
num = 10
​
​
def demo1():
​
    print(num)
​
​
def demo2():
​
    print(num)
​
demo1()
demo2()
​
print("over")
​
​

定义一个全局变量

num = 10
​
​
def demo1():
​
    print(num)
​
​
def demo2():
​
    print(num)
​
demo1()
demo2()
​
print("over")
​
​

注意：函数执行时，需要处理变量时 会：

1. 首先 查找 函数内部 是否存在 指定名称 的局部变量，如果有，直接使用

2. 如果没有，查找 函数外部 是否存在 指定名称 的全局变量，如果有，直接使用

3. 如果还没有，程序报错！

1) 函数不能直接修改 全局变量的引用

• 全局变量 是在 函数外部定义 的变量（没有定义在某一个函数内），所有函数 内部 都可以使用这个变量

• 在函数内部，可以 通过全局变量的引用获取对应的数据

• 但是，在函数内部不允许直接修改全局变量的引用 —— 使用赋值语句修改全局变量的值

num = 10
​
​
def demo1():
​
    print("demo1" + "-" * 50)
​
    # 只是定义了一个局部变量，不会修改到全局变量，只是变量名相同而已
    num = 100
    print(num)
​
​
def demo2():
​
    print("demo2" + "-" * 50)
    print(num)
​
demo1()
demo2()
​
print("over")
​
​

2) 在函数内部修改全局变量的值

• 如果在函数中需要修改全局变量，需要使用 global 进行声明

num = 10
​
​
def demo1():
​
    print("demo1" + "-" * 50)
​
    # global 关键字，告诉 Python 解释器 num 是一个全局变量
    global num
    # 只是定义了一个局部变量，不会修改到全局变量，只是变量名相同而已
    num = 100
    print(num)
​
​
def demo2():
​
    print("demo2" + "-" * 50)
    print(num)
​
demo1()
demo2()
​
print("over")
​
​

3、多值参数（知道）

定义支持多值参数的函数

• 有时可能需要 一个函数 能够处理的参数 个数 是不确定的，这个时候，就可以使用 多值参数

• python 中有 两种 多值参数：

  • 参数名前增加 一个 * 可以接收 元组

  • 参数名前增加 两个 * 可以接收 字典

• 一般在给多值参数命名时，习惯使用以下两个名字

  • *args —— 存放 元组 参数，前面有一个 *

  • **kwargs —— 存放 字典 参数，前面有两个 *

• args 是 arguments 的缩写，有变量的含义

• kw 是 keyword 的缩写，kwargs 可以记忆 键值对参数

def demo(num, *args, **kwargs):
​
    print(num)
    print(args)
    print(kwargs)
​
​
demo(1, 2, 3, 4, 5, name="小明", age=18, gender=True)
​
​

多值参数案例 —— 计算任意多个数字的和

需求

1. 定义一个函数 sum_numbers，可以接收的 任意多个整数

2. 功能要求：将传递的 所有数字累加 并且返回累加结果

def sum_numbers(*args):
​
    num = 0
    # 遍历 args 元组顺序求和
    for n in args:
        num += n
​
    return num
​
print(sum_numbers(1, 2, 3))
​

元组和字典的拆包（知道）

• 在调用带有多值参数的函数时，如果希望：

  • 将一个 元组变量，直接传递给 args

  • 将一个 字典变量，直接传递给 kwargs

• 就可以使用拆包，简化参数的传递，拆包的方式是：

  • 在 元组变量前，增加 一个 *

  • 在 字典变量前，增加 两个 *

def demo(*args, **kwargs):
​
    print(args)
    print(kwargs)
​
​
# 需要将一个元组变量/字典变量传递给函数对应的参数
gl_nums = (1, 2, 3)
gl_xiaoming = {"name": "小明", "age": 18}
​
# 会把 num_tuple 和 xiaoming 作为元组传递个 args
# demo(gl_nums, gl_xiaoming)
demo(*gl_nums, **gl_xiaoming)
​
​

4、递归

函数调用自身的 编程技巧 称为递归

4.1 递归函数的特点

特点

• 一个函数内部调用自己

  • 函数内部可以调用其他函数，当然在函数内部也可以调用自己

代码特点

1. 函数内部的 代码 是相同的，只是针对 参数 不同，处理的结果不同

2. 当参数满足一个条件时，函数不再执行

   • 这个非常重要，通常被称为递归的出口，否则 会出现死循环！

示例代码

def sum_numbers(num):
​
    print(num)
    
    # 递归的出口很重要，否则会出现死循环
    if num == 1:
        return
​
    sum_numbers(num - 1)
    
sum_numbers(3)
​
​

4.2 递归案例 —— 计算数字累加

需求

1. 定义一个函数 sum_numbers

2. 能够接收一个 num 的整数参数

3. 计算 1 + 2 + … num 的结果

def sum_numbers(num):
​
    if num == 1:
        return 1
    
    # 假设 sum_numbers 能够完成 num - 1 的累加
    temp = sum_numbers(num - 1)
​
    # 函数内部的核心算法就是 两个数字的相加
    return num + temp
​
print(sum_numbers(2))
​
​

六、模块

1、 什么是模块？

一个模块就是一个Python文件，文件名就是模块名字加上.py后缀。因此模块名称也必须符合变量名的命名规范。

2、为什么要使用模块？

如果你退出python解释器然后重新进入，那么你之前定义的函数或者变量都将丢失，因此我们通常将程序写到文件中以便永久保存下来，需要时就通过python test.py方式去执行，此时test.py被称为脚本script。

随着程序的发展，功能越来越多，为了方便管理，我们通常将程序分成一个个的文件，这样做程序的结构更清晰，方便管理。这时我们不仅仅可以把这些文件当做脚本去执行，还可以把他们当做模块来导入到其他的模块中，实现了功能的重复利用。（就跟函数功能差不多）参见以下这张图

3. 模块的概念

• 每一个以扩展名 py 结尾的 Python 源代码文件都是一个 模块

• 模块名 同样也是一个 标识符，需要符合标识符的命名规则

• 在模块中定义的 全局变量 、函数、类 都是提供给外界直接使用的 工具

• 模块 就好比是 一个工具包，要想使用这个工具包中的工具，就需要先 导入 这个模块

4. 模块的两种导入方式

1）import 导入

import 模块名1, 模块名2

提示：在导入模块时，每个导入应该独占一行

import 模块名1 import 模块名2 导入之后：通过 模块名. 使用 模块提供的工具 —— 全局变量、函数、类

使用 as 指定模块的别名：如果模块的名字太长，可以使用 as 指定模块的名称，以方便在代码中的使用

import 模块名1 as 模块别名

2）from…import 导入

• 如果希望 从某一个模块 中，导入 部分 工具，就可以使用 from … import 的方式

• import 模块名 是 一次性 把模块中 所有工具全部导入，并且通过 模块名/别名 访问

从 模块 导入 某一个工具
​
from 模块名1 import 工具名

• 导入之后：

  • 不需要 通过 模块名.

  • 可以直接使用 模块提供的工具 —— 全局变量、函数、类

七、常见的模块

1、random

random.random()

用于生成一个 0.0 到 1.0 的随机浮点数

>>> import random
>>> random.random()
0.9279749775408933
>>> random.random()
0.12720542394341363
>>> random.random()
0.9391670189487866
​

random.uniform(a,b)

生成一个[a,b]之间的随机小数；a, b 取整数 或 浮点数

>>> import random
>>> random.uniform(10.0, 20.0)
10.839456969258752
>>> random.uniform(10.0, 20.0)
12.233491867445115
>>> random.uniform(10, 20)
11.290563443261305
​

random.randint(a,b)

生成一个[a,b]之间的随机整数

>>> import random
>>> random.randint(10,100)
78
>>> random.randint(10,100)
56
>>> random.randint(10,100)
69
​

random.choice(seq)

从序列类型seq中随机返回一个元素；seq取序列类型：如字符串，列表，元组

>>> import random
>>> list = ['a', 'b', 'c', 'd', 'f', 'g']
>>> random.choice(list)
'b'
>>> random.choice(list)
'f'
>>> random.choice(list)
'g'
​

2、time

time库是python处理时间数据的标准库

对于这个库本人认为掌握sleep(),time()这两个方法已经足够了。

1、时间戳

获取当前时间戳，计算内部时间值，浮点数

>>> import time
>>> time.time()
1647853836.377331

2、time.sleep(num)

使用sleep(s) 函数可以让该线程睡眠s秒，s秒之后自动唤醒。s是拟休眠的时间，单位是秒，可以是浮点数。

import time
​
t1 = time.time()
time.sleep(2)  # 让程序睡眠两秒
t2 = time.time()
print("执行了 {:.3f} 秒".format(t2 - t1))
​

利用time模块可以计算一段程序的运行时间

import time
​
# 开始时间
start_time = time.time()
​
# 模拟代码执行（例如打印一些内容）
for i in range(5):
    print(f"执行步骤 {i+1}")
    # 暂停2秒
    time.sleep(2)
​
# 结束时间
end_time = time.time()
​
# 计算执行时间
execution_time = end_time - start_time
​
print(f"总执行时间: {execution_time:.2f} 秒")
​

3、turtle

这个我也不会，你们看课本吧，课本上都有。、

送你们一段代码，自己去运行下

from turtle import *
​
colormode(255)
​
lt(90)
​
lv = 14
l = 120
s = 45
​
width(lv)
​
r = 0
g = 0
b = 0
pencolor(r, g, b)
​
penup()
bk(l)
pendown()
fd(l)
​
def draw_tree(l, level):
    global r, g, b
    # save the current pen width
    w = width()
​
    # narrow the pen width
    width(w * 3.0 / 4.0)
    # set color:
    r = r + 1
    g = g + 2
    b = b + 3
    pencolor(r % 200, g % 200, b % 200)
​
    l = 3.0 / 4.0 * l
​
    lt(s)
    fd(l)
​
    if level < lv:
        draw_tree(l, level + 1)
    bk(l)
    rt(2 * s)
    fd(l)
​
    if level < lv:
        draw_tree(l, level + 1)
    bk(l)
    lt(s)
​
    # restore the previous pen width
    width(w)
​
speed("fastest")
​
draw_tree(l, 4)
​
done()#既然你都看到这里了，作为对执着者的奖励，我压一手题，模块的概念   递归的概念  全局 局部变量的概念
#字符串列表 字典的内容永远是最重要的  集合的元素不可重复（至于编程题嘛，过几天再更新，请持续关注）。

继续啊，编程题 质数的筛选  计算斐波那契数列  分解质因数  递归求阶乘 输入数组，最大的与第一个元素交换，最小的与最后一个元素交换，输出数组  大概率有          还有你们最好看一下课本上的全部例子

4、jieba（看课本）

5、wordcloud（看课本）

世界不只有眼前的苟且，还有诗与远方

我一直觉得，万事万物总是在变化，我们的人生也一样
在人生的无数岔路口，可能有着迷茫、无助、悔恨甚至愤怒，但不管怎么也好，路仍在脚下，我还是要继续走好自己的人生。
这篇文章是写给我自己的，也是写给看到这段文字的人的，希望未来，我和我们在岔路口迷失自我的时候，能想到这段文字。

人生有无数条岔路，我们无法选择一个完美的人生，但我们仍能立足当下、决定未来！

愿我能在迷茫的时候，找到前进的方向；愿我能在错误的时候，能清醒的更正；愿我能保持对知识的渴望，保持成长的动力，保持心中的那团火，因为那是我的热爱

最后，ok同学们买一瓶热带风味开始复习吧。