aaronxu/python-book
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

first commit

Browse Source
This commit is contained in:
aaronxu
2025-08-27 14:39:37 +08:00
commit 81ebee9cf3
97 changed files with 14191 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

913
01.基础语法/01.python基础.md Normal file
View File

@@ -0,0 +1,913 @@
# Python基础
## 安装python
略
## 运行python代码
在硬盘创建文件 t1.py，并且使用 PyCharm 打开，输入以下代码
```python
print('Hello World!')
```
然后右键运行
![image](01.python基础/1553917000771-909b5d59-8d4a-4e57-9dfe-95f0ba3a12ee.png)
运行结果
```
C:\Users\Aaron\AppData\Local\Programs\Python\Python35\python.exe C:/Users/Aaron/Desktop/py/t1.py
Hello World!
Process finished with exit code 0
```
## 注释
当行注释：# 被注释内容
多行注释：''' 被注释内容 '''，或者 """ 被注释内容 """
## 变量
变量是什么？ 变量：把程序运行的中间结果临时的存在内存里，以便后续的代码调用。
## 声明变量
```python
a = "Hello World!"
print(a)
```
## 变量定义的规则
- 变量名只能是 字母、数字或下划线的任意组合
- 变量名的第一个字符不能是数字
- 以下关键字不能声明为变量名
- ['and', 'as', 'assert', 'break', 'class', 'continue', 'def', 'del', 'elif', 'else', 'except', 'exec', 'finally', 'for', 'from', 'global', 'if', 'import', 'in', 'is', 'lambda', 'not', 'or', 'pass', 'print', 'raise', 'return', 'try', 'while', 'with', 'yield']
- 变量的定义要具有可描述性。
## 变量的赋值
```python
a = "变量1"
b = "变量2"
```
![image](01.python基础/1553917013597-9d6b5e70-3c79-4042-81a1-2459eca7cae8.png)
```python
a = "变量1"
b = a
```
![image](01.python基础/1553917020154-5c92c78b-e289-42a7-8b42-d6f563ed4dad.png)
## 常量
常量即指不变的量，如 pi 3.141592653..., 或在程序运行过程中不会改变的量。
## 程序交互
```python
name = input("请输入姓名：")
print(name)
```
执行脚本就会发现，程序会等待你输入姓名后再往下继续走。
```python
请输入姓名：Aaron
Aaron
```
## 基础数据类型
### 整数型（int）
在 32 位机器上，整数的位数为 32 位，取值范围为 -2**31～2**31-1，即 -2147483648～2147483647
在 64 位系统上，整数的位数为 64 位，取值范围为 -2**63～2**63-1，即 -9223372036854775808～9223372036854775807
注意：在 Python3 里不再有 long 类型了，全都是 int
```python
a = 2**64
print(type(a)) #type()是查看数据类型的方法
b = 2**60
print(type(b))
```
运行结果
```python
<class 'int'>
<class 'int'>
```
## 字符串类型（str）
在 Python 中, 加了引号的字符都被认为是字符串！
```python
a = "Eagle's Lab"
b = '''
欢迎大家来到英格科技!
今天我们学习python!'''
print(a,b)
```
运行结果
```python
Eagle's Lab
欢迎大家来到英格科技!
今天我们学习python!
```
字符串拼接
```python
a = 'eagle '
b = 'welcome '
print(b + a,'*' * 3,a * 3)
```
运行结果
```python
welcome eagle *** eagle eagle eagle
```
## 布尔值（True, False)
布尔类型很简单，就两个值 ，一个 True(真)，一个 False(假), 主要用记逻辑判断
```python
a = 3
b = 5
print(a < b, a > b , a != b)
```
运行结果
```
True False True
```
## 格式化输出
```python
name = input("姓名：")
age = input("年龄：")
job = input("工作：")
info = '''
----------- info of %s -----------
姓名：%s
年龄：%s
工作：%s
''' % (name,name,age,job)
print(info)
```
运行结果
```
姓名：Aaron
年龄：18
工作：Teacher
----------- info of Aaron -----------
姓名：Aaron
年龄：18
工作：Teacher
```
## 基本运算符
算数运算
| 运算符 | 描述 | 实例 |
| ------ | -------------- | ----------------- |
| + | 加 | a+b 输出结果30 |
| - | 减 | a-b 输出结果-10 |
| * | 乘 | a*b 输出结果200 |
| / | 除 | b/a 输出结果2 |
| % | 取模 得到余数 | b%a 输出结果0 |
| ** | 幂 | a**2 输出结果100 |
| // | 取整 | 9//2 输出结果4 |
比较运算
| 运算符 | 描述 | 实例 |
| ------ | -------- | ----------------- |
| == | 等于 | a == b 返回False |
| != | 不等于 | a != b 返回True |
| <> | 不等于 | a <> b 返回True |
| > | 大于 | a > b 返回False |
| < | 小于 | a < b 返回True |
| >= | 大于等于 | a >= b 返回False |
| <= | 小于等于 | a <= b 返回True |
赋值运算
| 运算符 | 描述 | 实例 |
| ------ | ---------------- | --------- |
| = | 赋值运算符 | c = a + b |
| += | 加法赋值运算符 | c += a |
| -= | 加法赋值运算符 | c -= a |
| *= | 乘法赋值运算符 | c *= a |
| /= | 除法赋值运算符 | c /= a |
| %= | 取模赋值运算符 | c %= a |
| **= | 幂赋值运算符 | c **= a |
| //= | 取整除赋值运算符 | c //= a |
逻辑运算
| 运算符 | 描述 | 实例 |
| ------ | ---- | ------------ |
| and | 与 | a and b |
| or | 或 | a or b |
| not | 非 | not(a and b) |
在没有 () 的情况下 not 优先级高于 and，and 优先级高于 or，即优先级关系为()>not>and>or，同一优先级从左往右计算。
x or y , x 为真，值就是 x，x 为假，值是 y； x and y, x 为真，值是 y,x 为假，值是 x。
成员运算
| 运算符 | 描述 | 实例 |
| ------ | ------------------------------------------------- | ---------- |
| in | 如果在指定的序列中找到值返回True,否则返回False | x in y |
| not in | 如果在指定的序列中没有找到返回True，否则返回False | x not in y |
```python
print('a' in 'abcd')
print('y' not in 'xyzasd')
```
运行结果
```
True
False
```
**Python 运算符优先级**
以下表格列出了从最高到最低优先级的所有运算符：
| 运算符 | 描述 |
| ------------------------ | ------------------------------------------------------ |
| ** | 指数 (最高优先级) |
| ~ + - | 按位翻转, 一元加号和减号 (最后两个的方法名为 +@ 和 -@) |
| * / % // | 乘，除，取模和取整除 |
| + - | 加法减法 |
| >> << | 右移，左移运算符 |
| & | 位 'AND' |
| ^ | 位运算符 |
| <= < > >= | 比较运算符 |
| <> == != | 等于运算符 |
| = %= /= //= -= += *= **= | 赋值运算符 |
| is is not | 身份运算符 |
| in not in | 成员运算符 |
| not and or | 逻辑运算符 |
## 流程控制之 --if
单分支
```python
if 条件:
满足条件后要执行的代码
```
双分支
```python
"""
if 条件:
满足条件执行代码
else:
if条件不满足就走这段
"""
age = 48
if age > 50 :
print("尚能饭否")
else:
print("廉颇老矣")
```
运行结果
```
廉颇老矣
```
if...else ... 可以有多个分支条件
```python
if 条件:
满足条件执行代码
elif 条件:
上面的条件不满足就走这个
elif 条件:
上面的条件不满足就走这个
elif 条件:
上面的条件不满足就走这个
else:
上面所有的条件不满足就走这段
```
## 流程控制之 --while
基本循环
```python
while 条件:
循环体
```
如果条件为真，那么循环体则执行
如果条件为假，那么循环体不执行
循环中止语句
break 用于完全结束一个循环，跳出循环体执行循环后面的语句
continue 和 break 有点类似，区别在于 continue 只是终止本次循环，接着还执行后面的循环，break 则完全终止循环
```python
print('猜数字游戏开始')
num = 54
while True:
guess = int(input("您猜数字是什么？(输入0-100的数字)"))
if guess < num:
print("您猜小了")
continue
elif guess > num:
print("您猜大了")
continue
break
print("您猜对了！")
```
运行结果
```
猜数字游戏开始
您猜数字是什么？(输入0-100的数字)50
您猜小了
您猜数字是什么？(输入0-100的数字)60
您猜大了
您猜数字是什么？(输入0-100的数字)54
您猜对了！
```
while ... else ..
while 后面的 else 作用是指，当 while 循环正常执行完，中间没有被 break 中止的话，就会执行 else 后面的语句
## 基础数据类型
### 数字 (int)
```python
v = 11
data = v.bit_length() #当十进制用二进制表示时，最少使用的位数
print(data)
```
运行结果
```
4
```
### 布尔值 ()bool
布尔值就两种：True，False。就是反应条件的正确与否。
真 1 True。
假 0 False。
### 字符串 str
#### 字符串的索引与切片
```python
a = 'ABCDEFGHIJK'
print(a[0])
print(a[3])
print(a[5])
print(a[7])
a = 'ABCDEFGHIJK'
print(a[0:3])
print(a[2:5])
print(a[0:]) #默认到最后
print(a[0:-1]) # -1 是列表中最后一个元素的索引，但是要满足顾头不顾腚的原则，所以取不到K元素
print(a[0:5:2]) #加步长
print(a[5:0:-2]) #反向加步长
```
运行结果
```
A
D
F
H
ABC
CDE
ABCDEFGHIJK
ABCDEFGHIJ
ACE
FDB
```
#### 字符串常用方法
```python
words = "beautiful is better than ugly."
print(words.capitalize()) #首字母大写
print(words.swapcase()) #大小写翻转
print(words.title()) #每个单词的首字母大写
## 内容居中，总长度，空白处填充
a = "test"
ret = a.center(20,"*")
print(ret)
## 数字符串中的元素出现的个数
ret = words.count("e",0,30)
print(ret)
a = "aisdjioadoiqwd12313assdj"
## startswith 判断是否以...开头
## endswith 判断是否以...结尾
print(a.startswith("a"))
print(a.endswith("j"))
print(a.startswith('sdj',2,5))
print(a.endswith('ado',7,10))
## 寻找字符串中的元素是否存在
print(a.find('sdj',1,10)) # 返回的找到的元素的索引，如果找不到返回-1
print(a.index('sdj',1,10)) # 返回的找到的元素的索引，找不到报错。
## split 以什么分割，最终形成一个列表此列表不含有这个分割的元素。
ret = words.split(' ')
print(ret)
ret = words.rsplit(' ',2)
print(ret)
## format的三种玩法 格式化输出
print('{} {} {}'.format('aaron',18,'teacher'))
print('{1} {0} {1}'.format('aaron',18,'teacher'))
print('{name} {age} {job}'.format(job='teacher',name='aaron',age=18))
## strip
a = '****asdasdasd********'
print(a.strip('*'))
print(a.lstrip('*'))
print(a.rstrip('*'))
## replace
print(words.replace('e','a',2))
print(words.isalnum()) #字符串由字母或数字组成
print(words.isalpha()) #字符串只由字母组成
print(words.isdigit()) #字符串只由数字组成
```
### 元祖 tuple
元组被称为只读列表，即数据可以被查询，但不能被修改。
### 列表 list
列表相比于字符串，不仅可以储存不同的数据类型，而且可以储存大量数据，32 位 python 的限制是 536870912 个元素,64 位 python 的限制是 1152921504606846975 个元素。而且列表是有序的，有索引值，可切片，方便取值。
#### 增
```python
li = [1,'a',2,'d',4]
li.insert(0,22) # 按照索引去增加
print(li)
li.append('ddd') # 增加到最后
print(li)
li.extend(['q,a,w']) # 迭代的去增
print(li)
li.extend(['q,a,w','das']) # 迭代的去增
print(li)
```
运行结果
```
[22, 1, 'a', 2, 'd', 4]
[22, 1, 'a', 2, 'd', 4, 'ddd']
[22, 1, 'a', 2, 'd', 4, 'ddd', 'q,a,w']
[22, 1, 'a', 2, 'd', 4, 'ddd', 'q,a,w', 'q,a,w', 'das']
```
#### 删
```python
li = [1,'a',2,'d',4,5,'f']
a = li.pop(1) # 按照位置去删除，有返回值
print(a)
del li[1:3] # 按照位置去删除，也可切片删除没有返回值。
print(li)
li.remove('f')
print(li)
li.clear()
print(li)
```
运行结果
```
a
[1, 4, 5, 'f']
[1, 4, 5]
[]
```
#### 改
```python
li = [1,'a',2,'d',4,5,'f']
li[1] = 'aaa'
print(li)
li[2:3] = [3,'e']
print (li)
```
运行结果
```
[1, 'aaa', 2, 'd', 4, 5, 'f']
[1, 'aaa', 3, 'e', 'd', 4, 5, 'f']
```
#### 查
切片去查，或者循环去查。
#### 其他操作
```python
li = [1,2,4,5,4,2,4]
print (li.count(4)) # 统计某个元素在列表中出现的次数
print (li.index(2)) # 用于从列表中找出某个值第一个匹配项的索引位置
li.sort() # 用于在原位置对列表进行排序
print (li)
li.reverse() # 将列表中的元素反向存放
print (li)
```
运行结果
```
3
1
[1, 2, 2, 4, 4, 4, 5]
[5, 4, 4, 4, 2, 2, 1]
```
### 字典dict
字典是python中唯一的映射类型，采用键值对（key-value）的形式存储数据。python对key进行哈希函数运算，根据计算的结果决定value的存储地址，所以字典是无序存储的，且key必须是可哈希的。可哈希表示key必须是不可变类型，如：数字、字符串、元组。
#### 增
```python
dic = {"age":18, "name":"aaron"}
dic['li'] = ["a","b","c"]
print(dic)
dic.setdefault('k','v')
## 在字典中添加键值对，如果只有键那对应的值是none,但是如果原字典中存在设置的键值对，则他不会更改或者覆盖。
print(dic)
dic.setdefault('k','v1')
print(dic)
```
#### 删
```python
dic = {"age":18, "name":"aaron"}
dic_pop = dic.pop('age')
## pop根据key删除键值对，并返回对应的值，如果没有key则返回默认返回值
print(dic_pop)
dic_pop = dic.pop('sex','查无此项')
print(dic_pop)
dic['age'] = 18
print(dic)
del dic['name']
print(dic)
dic['name'] = 'demo'
dic_pop = dic.popitem()
## 随机删除字典中的某个键值对，将删除的键值对以元祖的形式返回
print(dic_pop)
dic_clear = dic.clear()
## 清空字典
print(dic,dic_clear)
```
#### 改
```python
dic = {"age":18, "name":"aaron", 'sex':'male'}
dic2 = {"age":30, "name":'demo'}
dic2.update(dic)
## 将dic所有的键值对覆盖添加（相同的覆盖，没有的添加）到dic2中
print(dic2)
dic2['age'] = 30
print(dic2)
```
#### 查
```python
dic = {"age":18, "name":"aaron", 'sex':'male'}
value = dic['name']
## 没有会报错
print(value)
value = dic.get('abc','查无此项')
print(value)
```
#### 其他操作
```python
dic = {"age":18, "name":"aaron", 'sex':'male'}
for i in dic.items():
# 将键和值作为元祖列出
print(i)
for key,value in dic.items():
print(key,value)
for i in dic:
# 只是迭代键
print(i)
keys = dic.keys()
print(keys,type(keys))
value = dic.values()
print(value,type(value))
```
### 集合set
集合是无序的，不重复的数据集合，它里面的元素是可哈希的(不可变类型)，但是集合本身是不可哈希（所以集合做不了字典的键）的。以下是集合最重要的两点：
- 去重，把一个列表变成集合，就自动去重了。
- 关系测试，测试两组数据之前的交集、差集、并集等关系。
#### 创建集合
```python
set1 = set({1,2,'barry'})
set2 = {1,2,'barry'}
print(set1,set2)
```
#### 集合的增
```python
set1 = {'abc','def',123,'asdas'}
set1.add('qwer')
print(set1)
set1.update('A')
#update：迭代着增加
print(set1)
set1.update('哈哈哈')
print(set1)
set1.update([1,2,3])
print(set1)
```
#### 集合的删
```python
set1 = {'abc','def',123,'asdas'}
set1.remove('abc')
print(set1)
set1.pop()
## 随机删除一个数
print(set1)
set1.clear()
## 清空合集
print(set1)
del set1
## 删除合集
print(set1)
```
#### 集合的其他操作
###### 交集（& 或者 intersection）
```python
set1 = {1,2,3,4,5}
set2 = {3,4,5,6,7}
print(set1 & set2)
print(set1.intersection(set2))
## 列出两个集合中共同拥有的项
```
##### 并集（|或者 union）
```python
set1 = {1,2,3,4,5}
set2 = {3,4,5,6,7}
print(set1 | set2)
print(set2.union(set1))
## 列出两个集合中所有的项
```
##### 差集（- 或者 difference）
```python
set1 = {1,2,3,4,5}
set2 = {3,4,5,6,7}
print(set1 - set2)
print(set1.difference(set2))
## 在set1中删除set2中有的项
```
##### 反交集 （^ 或者 symmetric_difference）
```python
set1 = {1,2,3,4,5}
set2 = {3,4,5,6,7}
print(set1 ^ set2)
print(set1.symmetric_difference(set2))
## 显示set1和set2不共存的项
```
##### 子集与超集
```python
set1 = {1,2,3}
set2 = {1,2,3,4,5,6}
print(set1 < set2)
print(set1.issubset(set2)) # 这两个相同，都是说明set1是set2子集。
print(set2 > set1)
print(set2.issuperset(set1)) # 这两个相同，都是说明set2是set1超集
```
##### frozenset不可变集合，让集合变成不可变类型
```python
set1 = {1,2,3,4,5,6}
s = frozenset(set1)
print(s,type(s))
s.add(7) # 不可以修改,会报错
```
## 基础数据类型的总结
### 按存储空间的占用分（从低到高）
1. 数字
2. 字符串
3. 集合：无序，即无序存索引相关信息
4. 元组：有序，需要存索引相关信息，不可变
5. 列表：有序，需要存索引相关信息，可变，需要处理数据的增删改
6. 字典：无序，需要存key与value映射的相关信息，可变，需要处理数据的增删改
### 按存值个数区分
| 标量／原子类型 | 数字，字符串 |
| -------------- | ---------------- |
| 容器类型 | 列表，元组，字典 |
### 按可变不可变区分
| 可变 | 列表，字典 |
| ------ | -------------------------- |
| 不可变 | 数字，字符串，元组，布尔值 |
### 按访问顺序区分
| 直接访问 | 数字 |
| --------------------- | ------------------ |
| 顺序访问（序列类型） | 字符串，列表，元组 |
| key值访问（映射类型） | 字典 |
## 其他（for，enumerate，range）
for循环：用户按照顺序循环可迭代对象的内容。
```python
s = '先帝创业未半而中道崩殂，今天下三分，益州疲弊，此诚危急存亡之秋也。'
for i in s:
print(i)
li = ['甲','乙','丙','丁']
for i in li:
print(i)
dic = {'a':1,'b':2,'c':3}
for k,v in dic.items():
print(k,v)
```
enumerate：枚举，对于一个可迭代的（iterable）/可遍历的对象（如列表、字符串），enumerate将其组成一个索引序列，利用它可以同时获得索引和值。
```python
li = ['甲','乙','丙','丁']
for i in li:
print(i)
for i in enumerate(li):
print(i)
for index,value in enumerate(li):
print(index,value)
for index,value in enumerate(li,100): #从哪个数字开始索引
print(index,value)
```
range：指定范围，生成指定数字。
```python
for i in range(1,10):
print(i)
for i in range(1,10,2): # 步长
print(i)
for i in range(10,1,-2): # 反向步长
print(i)
```