Python教程
【合集】Python基础知识【第二版】
本文主要是介绍【合集】Python基础知识【第二版】，对大家解决编程问题具有一定的参考价值，需要的程序猿们随着小编来一起学习吧！
更新部分
- 为了避免冗长的代码影响大家观感，将部分案例拆开
- 增加部分知识点，为了减少大家阅读的负担，尽可能使用短句子，但知识点不可能全覆盖，笔者不是写书，就算是写书也不可能全面，请同学们自行去补充
- 增加部分案例，但是目前笔者能力有限，大部分都是书上的案例直接拉过来，并且为了不影响观感案例不会太多，大部分为抛砖引玉，请同学们灵活变通
编程基础
基本输入输出
print("Hello World");
Name = input('请输入您的姓名：');
print(Name);
D:\工作空间\Python\venv\Scripts\python.exe D:/工作空间/Python/main.py Hello World 请输入您的姓名：Alice Alice 进程已结束,退出代码0
变量
print("-------------输出语句-------------");
message="Hello Python world";
print(message);
print("-------------首字母大写-------------");
name="ada lovelace";
print(name.title());
print("-------------大小写-------------");
print(name.upper());
print(name.lower());
print("-------------拼接字符串-------------");
first_name = "ada"
last_name = "lovelace"
full_name = first_name + " " + last_name
print(full_name);
print("-------------添加空白-------------");
print("\tPython");
print("Languages:\nPython\nC\nJavaScript");
print("-------------删除空白-------------");
print("Hello ".rstrip());
print("-------------运算-------------");
print(2+3);
print(3-2);
print(2*3);
print(3/2);
print(3**2);
print(3**3);
print(10**6);
print(0.1+0.1);
print(0.2+0.2);
print("------------注释-------------");
# 测试注释
-------------输出语句------------- Hello Python world -------------首字母大写------------- Ada Lovelace -------------大小写------------- ADA LOVELACE ada lovelace -------------拼接字符串------------- ada lovelace -------------添加空白------------- Python Languages: Python C JavaScript -------------删除空白------------- Hello -------------运算------------- 5 1 6 1.5 9 27 1000000 0.2 0.4 ------------注释------------- Process finished with exit code 0
- 运行文件hello_world.py时，末尾的.py指出这是一个Python程序，因此编辑器将使用Python解释器来运行它
- 变量名只能包含字母、数字和下划线。变量名可以字母或下划线打头，但不能以数字打头，例如，可将变量命名为message_1，但不能将其命名为1_message。
- 变量名不能包含空格，但可使用下划线来分隔其中的单词。例如，变量名greeting_message可行，但变量名greeting message会引发错误。
- 不要将Python关键字和函数名用作变量名，即不要使用Python保留用于特殊用途的单词，
- 变量名应既简短又具有描述性。
- 慎用小写字母l和大写字母O，因为它们可能被人错看成数字1和0
- 在Python中，注释用井号（ # ）标识。井号后面的内容都会被Python解释器忽略
基本运算符
print("-----------------算数运算符-----------------");
#+ 加，两个对象相加
#- 减，得到负数或是一个数减去另一个数
#* 乘，两个数相乘或是返回一个被重复若干次的字符串
#x/y 除，x 除以 y
#% 取模，返回除法的余数
#// 取整除，返回商的整数部分
#x**y 幂
print(12+13);
print(12-13);
print(12*13);
print(12/13);
print(12/13);
print(12%13);
print(12//13);
print(12**13);
print("-----------------比较运算符-----------------");
#== 等于，比较对象是否相等 （a == b）返回 False
#!= 不等于，比较两个对象是否不相等 （a != b）返回 True
#<> 不等于，比较两个对象是否不相等 （a <> b）返回 True。这个运算符类似 !=
#x > y 大于，返回 x 是否大于 y （a > b）返回 False
#x < y小于，返回 x 是否小于 y。所有比较运算符返回 1表示真，返回 0 表示假。这分别与特殊的变量 True 和 False 等价。注意这些变量名的大小写（a < b）返回 True
#x >= y 大于等于，返回 x 是否大于等于 y （a >= b）返回 False
#x <= y 小于等于，返回 x 是否小于等于 y （a <= b）返回 True
print(12>13);
print(12>=13);
print(12<13);
print(12<=13);
print(12!=13);
print(12==13);
print("-----------------赋值运算符-----------------");
#= 简单的赋值运算符 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
#//= 取整除赋值运算符 c //= a 等效于 c = c // a
a=21;
b=10;
c=0;
c+=a;
print(c);
c*=b;
print(c);
c/=a;
print(c);
c-=b;
print(c);
c=2;
c%=a;
print(c);
c**=a;
print(c);
c//=a;
print(c);
print("-----------------位运算符-----------------");
#& 按位与运算符 （a & b）输出结果 12，二进制解释：0000 1100
#| 按位或运算符 （a | b）输出结果 61，二进制解释：0011 1101
#^ 按位异或运算符 （a ^ b）输出结果 49，二进制解释：0011 0001
#～ 按位取反运算符
#（～a）输出结果−61，二进制解释：1100 0011，
#在一个有符号二进制数的补码形式
#<< 左移动运算符 a << 2 输出结果 240，二进制解释：1111 0000
#>> 右移动运算符 a >> 2 输出结果 15，二进制解释：0000 1111
a=60;
b=13;
c=0;
c=a&b;
print(c);
c=a|b;
print(c);
c=a^b;
print(c);
c=~a;
print(c);
c=a<<2;
print(c);
c=a>>2;
print(c);
print("-----------------逻辑运算符-----------------");
#x and y 布尔“与”，如果 x 为 False，x and y 返回 False，否则它返回 y 的计算值
#x or y 布尔“或”，如果 x 是 True，它返回 True，否则它返回 y 的计算值
#x not y 布尔“非”，如果 x 为 True，返回 False。如果 x 为 False，它返回 True
a=10;
b=20;
print(a and b);
a=0;
print(a and b);
D:\工作空间\Python\venv\Scripts\python.exe D:/工作空间/Python/main.py -----------------算数运算符----------------- 25 -1 156 0.9230769230769231 0.9230769230769231 12 0 106993205379072 -----------------比较运算符----------------- False False True True True False -----------------赋值运算符----------------- 21 210 10.0 0.0 2 2097152 99864 -----------------位运算符----------------- 12 61 49 -61 240 15 进程已结束,退出代码0
- 截取除法（//）的结果是整数，并且整数和浮点数均可应用。
- 除法（/）：在 Python 2.X 中，如果操作数是整数，除法结果取整数，但在 Python 3.X中，结果是浮点数。
- 对浮点数来说，取余运算的结果是“a // b”的浮点数余数，即“a –（a//b）*b”。
- 对于复数，取余和截取除法是无效的。
- 对于比较运算符，可以有更复杂的写法，如：“a<b<c”，这相当于“a<b and b<c”，又如：“a<b>c”，相当于“a<b and b>c”，“a==b>c”相当于“a==b and b>c”。
- 不允许对复数进行比较。
- 只有当操作数是同一类型时，比较才有效。对于内置的数字对象，当两个操作数类型不一致时，Python 将进行类型的强制转换，例如，当操作数之一为浮点数时，则将另一个操作数也转换为浮点。
- not a：如果 a 为 False，则返回 1，否则返回 0。
- a and b：如果 a 为 False，则返回 a，否则返回 b。
- a or b：如果 a 为 False，则返回 b，否则返回 a。
- 身份运算符用 is、is not 表示，用于比较两个对象的存储单元。is not 是特殊的比较运算符，比较的是对象的存储单元，实际进行的是存储单元的比较。
- 存储单元地址可以使用函数 id( )进行查看，存储单元取值也可以采用函数 id( )。
控制流程
选择结构
print("-------------检查是否相等-------------");
car='bmw';
print(car=='bmw');
print(car=='audi');
print(car=='BMW');
print(car.upper()=='BMW');
age=18;
print(age==18);
print(age>=18);
print(age<=18);
print(age>18);
print(age<18);
age_0 = 22;
age_1 = 18;
print(age_0 >= 21 and age_1 >= 21);
print(age_0 >= 21 or age_1 >= 21);
print("-------------if语句-------------");
age = 19
if age >= 18:
print("You are old enough to vote!");
age=17
if age>=18:
print("You are old enough to vote!");
else:
print("Sorry you are too young");
age = 12
if age < 4:
print("Your admission cost is $0.")
elif age < 18:
print("Your admission cost is $5.")
else:
print("Your admission cost is $10.")
age = 12
if age < 4:
price = 0
elif age < 18:
price = 5
elif age < 65:
price = 10
elif age >= 65:
price = 5
print("Your admission cost is $" + str(price) + ".")
-------------检查是否相等------------- True False False True True True True False False False True -------------if语句------------- You are old enough to vote! Sorry you are too young Your admission cost is $5. Your admission cost is $5. Process finished with exit code 0
- 在Python中检查是否相等时区分大小写
- 要判断两个值是否不等，可结合使用惊叹号和等号（ != ）
- 要检查是否两个条件都为 True ，可使用关键字 and 将两个条件测试合而为一
- 关键字 or 也能够让你检查多个条件，但只要至少有一个条件满足，就能通过整个测试。
- 在 if 语句中，缩进的作用与 for 循环中相同。如果测试通过了，将执行 if 语句后面所有缩进的代码行，否则将忽略它们。
- 经常需要检查超过两个的情形，为此可使用Python提供的 if-elif-else 结构
循环结构
print("-------------函数input()的工作原理-------------");
message = input("Tell me something, and I will repeat it back to you: ")
print(message)
print("-------------编写清晰的程序-------------");
name=input("Please enter your name:");
print("Hello,"+name+"!");
print("-------------求模运算符-------------");
print(4%3);
print("-------------while循环-------------");
current_number = 1
while current_number <= 5:
print(current_number)
current_number += 1
print("-------------让用户选择何时退出-------------");
prompt = "\nTell me something, and I will repeat it back to you:"
prompt += "\nEnter 'quit' to end the program. "
message = ""
while message != 'quit':
message = input(prompt)
print(message)
print("-------------break语句-------------");
prompt = "\nPlease enter the name of a city you have visited:"
prompt += "\n(Enter 'quit' when you are finished.) "
while True:
city = input(prompt)
if city == 'quit':
break
else:
print("I'd love to go to " + city.title() + "!")
-------------函数input()的工作原理------------- Tell me something, and I will repeat it back to you: Hello World Hello World -------------编写清晰的程序------------- Please enter your name:Alice Hello,Alice! -------------求模运算符------------- 1 -------------while循环------------- 1 2 3 4 5 -------------让用户选择何时退出------------- Tell me something, and I will repeat it back to you: Enter 'quit' to end the program. Hello World Hello World Tell me something, and I will repeat it back to you: Enter 'quit' to end the program. quit quit -------------break语句------------- Please enter the name of a city you have visited: (Enter 'quit' when you are finished.) ShangHai I'd love to go to Shanghai! Please enter the name of a city you have visited: (Enter 'quit' when you are finished.) quit Process finished with exit code 0
- 函数 input() 让程序暂停运行，等待用户输入一些文本。获取用户输入后，Python将其存储在一个变量中，以方便你使用。
- 函数 input() 接受一个参数：即要向用户显示的提示或说明，让用户知道该如何做。
- 每当你使用函数 input() 时，都应指定清晰而易于明白的提示，准确地指出你希望用户提供什么样的信息——指出用户该输入任何信息的提示都行
- 使用函数 input() 时，Python将用户输入解读为字符串
- break 语句用来终止整个循环（当前循环），即循环条件没有为 False 或者序列还没被完全递归完，也会停止执行循环语句。
- break 语句用在 while 和 for 循环中。
- 如果使用嵌套循环，break 语句将停止执行当前的循环，并开始执行下一行代码。
- continue 语句用来跳出本次循环，而 break 语句用于跳出整个循环。
- continue 语句用来告诉 Python 跳过当前循环的剩余语句，然后继续进行下一轮循环。
- Python 的 pass 语句是空语句，是为了保持程序结构的完整性。pass 语句不做任何事情，一般作占位语句。
- 在 Python 中，while … else 表示这样的意思，while 中的语句和普通的没有区别，else中的语句会在循环正常执行完（即 while 语句不是通过 break 跳出而中断的）的情况下执。
- 在 Python 中，for … else 表示这样的意思，for 中的语句和普通的语句没有区别，else 中的语句会在循环正常执行完（即 for 语句不是通过 break 跳出而中断的）的情况下执行。
数据类型
字符串
print("-------------字符串操作-------------");
#coding=utf-8
str = 'Hello World!'
print(str) # 输出完整字符串
print(str[0]) # 输出字符串中的第一个字符
print(str[2:5]) # 输出字符串中第三个至第五个之间的字符串
print(str[2:]) # 输出从第三个字符开始的字符串
print(str * 2) # 输出字符串两次
print(str + "TEST") # 输出连接的字符串
print("-------------格式化输出-------------");
x="欢迎您，%s，当前第%d 次访问! "
y=x%("小明",1)
#y=("欢迎您，%s，当前第%d 次访问! "%("小明",1))，以上两行可以合并为这一行。
print(y)
print("-------------三引号-------------");
hi = '''hi
there'''
print(hi) # str()
D:\工作空间\Python\venv\Scripts\python.exe D:/工作空间/Python/main.py -------------字符串操作------------- Hello World! H llo llo World! Hello World!Hello World! Hello World!TEST -------------格式化输出------------- 欢迎您，小明，当前第1 次访问! -------------三引号------------- hi there 进程已结束,退出代码0
- 字符串是 Python 中最常用的数据类型。我们可以使用引号来创建字符串。
- 字符串在内存中存储，每个字符都对应一个编号，常见的编号以 0 开始，依次加 1Python 的字符串列表有两种取值顺序：
- 从左到右索引默认是从 0 开始的，最大范围是字符串长度减去 1。
- 从右到左索引默认是从-1 开始的，最大范围是字符串开头。
- 如果要取得一段子串的话，用变量[头下标：尾下标]截取相应的字符串，其中下标是从 0开始算起的，可以是正数或负数，下标可以为空，表示取到头或尾。
- + 字符串连接 a + b 输出结果：HelloPython
- * 重复输出字符串 a*2 输出结果：HelloHello
- [] 通过索引获取字符串中字符 a[1] 输出结果 e
- [：] 截取字符串中的一部分 a[1:4] 输出结果 ell
- in 成员运算符，如果字符串中包含给定的字符则返回 True H in a 输出结果 1
- not in 成员运算符，如果字符串中不包含给定的字符则返回True M not in a 输出结果 1
- r/R 原始字符串，所有的字符串都是直接按照字面的意思来使用的，没有转义特殊或不能打印的字符。原始字符串除在字符串的第一个引号前加上字母“r”（可以大小写），与普通字符串有着几乎完全相同的语法
- % 格式字符串
- Python 不支持单字符类型，单字符在 Python 中也是作为一个字符串使用的，单字符的取值方式和字符串相同，只有一个下标值[0]。
- print( )函数可以采用格式化输出形式：print('格式串'%(对象 1，对象 2，...))
- 使用 format 格式化输出时，之前同样需要占位，不过此时不采用%占位符，而是采用{}占位，需要在什么位置插入相关数据，则在相关位置插入{}号
- Python 三引号允许一个字符串跨多行，字符串中可以包含换行符、制表符及其他特殊字符。
列表
print("-------------创建列表-------------");
list1 = ['JAVA', 'Hello', 'Python', 'VS', 1, 2, 3]
print(list1)
list2 = list('Python')
print(list2)
list3 = []
print(list3)
print("-------------访问列表中的值-------------");
print("list1[0]: ", list1[0])
print("list2[1:5]: ", list2[1:5])
print("-------------列表函数-------------");
list1.append('XYZ') #向 list1 增加'XYZ'对象
print(list1.count('Python')) #返回'Python'出现次数
list1.extend(list2) #将 list2 加到 list1 后面
print(list1)
list1.remove('XYZ') #删除对象'XYZ'
print(list1.pop()) # 删除列表的最后位置上的对象并返回
print(list1)
D:\工作空间\Python\venv\Scripts\python.exe D:/工作空间/Python/main.py -------------创建列表------------- ['JAVA', 'Hello', 'Python', 'VS', 1, 2, 3] ['P', 'y', 't', 'h', 'o', 'n'] [] -------------访问列表中的值------------- list1[0]: JAVA list2[1:5]: ['y', 't', 'h', 'o'] -------------列表函数------------- 1 ['JAVA', 'Hello', 'Python', 'VS', 1, 2, 3, 'XYZ', 'P', 'y', 't', 'h', 'o', 'n'] n ['JAVA', 'Hello', 'Python', 'VS', 1, 2, 3, 'P', 'y', 't', 'h', 'o'] 进程已结束,退出代码0
- 用方括号（[]）将一组 Python 对象括起来，Python 对象之间用逗号分隔。
- 列表操作符包括长度取值、连接、重复、成员检查和迭代检查。
- 使用下标索引来访问列表中的值，同样可以使用方括号的形式截取字符
元祖
print("-------------创建访问元祖-------------");
#coding=utf-8
tuple = ( 'Java', 786 , 2.23, 'john', 70.2 )
tinytuple = (123, 'john')
print(tuple) # 输出完整元组
print(tuple[0])# 输出元组的第一个元素
print(tuple[1:3]) # 输出第二个至第三个的元素
print(tuple[2:])# 输出从第三个开始至列表末尾的所有元素
print(tinytuple * 2) # 输出元组两次
print(tuple + tinytuple) # 打印组合的元组
D:\工作空间\Python\venv\Scripts\python.exe D:/工作空间/Python/main.py
-------------创建访问元祖-------------
('Java', 786, 2.23, 'john', 70.2)
Java
(786, 2.23)
(2.23, 'john', 70.2)
(123, 'john', 123, 'john')
('Java', 786, 2.23, 'john', 70.2, 123, 'john')
进程已结束,退出代码0
- 创建元组与创建列表一样，只是其用圆括号而已。
- 访问元组的元素也是通过切片操作实施的，操作与列表一样。
- 元组中的元素值是不允许修改的
- 元组中的元素值是不允许删除的，但我们可以使用 del 语句来删除整个元组
- 与字符串一样，元组之间可以使用 + 号和 * 号进行运算。这就意味着它们可以组合和复制，运算后会生成一个新的元组
- 因为元组也是一个序列，所以我们可以访问元组中的指定位置的元素，也可以截取索引中的一段元素
- 任意无符号的对象，以逗号隔开，默认为元组
- 元组的不可变性带来的好处。元组的元素不可变，编写程序时，可以利用这个不可性保存数据，不被修改。因为元组不可变，所以元组可以作为字典的关键字使用。
- 和列表一样，元组也可以嵌套列表或元组。嵌套的子对象的可变性不受元组不可变的限制
字典
print("-------------创建字典-------------");
d1 = {} # 空字典
d2={"id":10,"tel":123456,"name":"小明"}
print(d1)
print(d2)
print("-------------访问字典-------------");
dict2 = {'name': '小明','id':1, 'dept': '计算机'}
print(dict2['dept'])
print(dict2['name'])
print("-------------修改添加字典-------------");
dict1 = {'Name':'小明', 'Age':19, 'major':'计算机'};
dict1['Age'] = 18; # 字典中有"Age"键，更新现有元素
dict1['college'] = "Tech"; # 字典中无"college"键，执行添加操作
print("dict1['Age']: ",dict1['Age'])
print("dict1['college']: ",dict1['college'])
print("-------------删除字典-------------");
dict1={"stu_name":"小明","stu_id":1,"stu_age":24}
del dict1["stu_id"] # 删除键为"stu_id"的键值对
print(dict1)
dict1.clear() # 删除所有键值对
print(dict1)
D:\工作空间\Python\venv\Scripts\python.exe D:/工作空间/Python/main.py
-------------创建字典-------------
{}
{'id': 10, 'tel': 123456, 'name': '小明'}
-------------访问字典-------------
计算机
小明
-------------修改添加字典-------------
dict1['Age']: 18
dict1['college']: Tech
-------------删除字典-------------
{'stu_name': '小明', 'stu_age': 24}
{}
进程已结束,退出代码0
- 列表是有序的对象结合，字典是无序的对象集合。两者之间的区别在于：字典当中的元素是通过键来存取的，而不是通过顺序偏移存取。
- 字典用“{ }”标识。字典由索引（键 key）和它对应的值（value）组成。字典由键和对应值成对组成。字典也被称为关联数组或哈希表。
- 字典是键值对的无序集合。所谓键值对（又称条目、或元素）是指字典中的每个元素由键和值（又称数据项）两个部分组成，键是关键字，值是与关键字有关的数据。通过键可以找到与其有关的值，反过来则不行，不能通过值找键。
- 字典的定义是：在一对花括号（{、}）之间添加 0 个或多个元素，元素之间用逗号分隔；元素是键值对，键与值之间用冒号分隔；键必须是不可变对象，键在字典中必须是唯一的，值可以是不可变对象或可变对象。
- 键必须是不可变对象。这是说键必须是可哈希的，也就是说键可以通过哈希函数计算出对应值的存储位置。在字典中，通常将数字对象和字符串对象作为键，并将整数对象和浮点数对象作为同一个键，如整数 1 和浮点数 1.0 是同一个键。元组是不可变对象，原则上是可以作键使用的，但要求元组的元素是数字或字符串。
- 键在字典中必须是唯一的。如果有同名键存在，系统将用最后一个键值对取代前一个，以保证键的唯一性。
- 创建字典直接使用{}键入，用 dict( )函数创建字典，用 fromkeys( )方法创建字典。
- 访问字典里的值，格式简单，采用直接的访问方法，格式如下：<字典>[<键>]也就是“字典对象[key]”，key 如果是字符串，需要加引号；如果是数字，不能加引号。
- 字典中的元素都是以“键值对（key：value）”的方式存在的。在字典中，要想修改一个元素的值，可根据字典中的键名找到所对应的值，然后直接赋值即可。修改格式如下：字典["键名"]=值
- 可以删除单一的元素也可以清空字典。单一元素的删除操作：在字典中，元素是以一个键值对方式存在的，删除元素时，取键（key）即可，格式为：del 字典元素
- 不允许同一个键出现两次。创建时如果同一个键被赋值两次，后一个值会被记住，余下的将被抛弃
- 键必须不可变，可以用数、字符串或元组充当，但不能用列表或字典
集合
print("-------------创建集合-------------");
s = set() # 空集
print(s)
print(type(s))
s = {1,2,3} # 直接写入集合元素
print(type(s))
s=set(["ABC",'XYZ','xyz','123','1',1,1.0])
print(s)
s=set(i for i in range(10))
print(s)
s=frozenset("Python 3.3.3")
print(s)
s= dict((i,0) for i in {1, 'ABC', 'XYZ', 'xyz', '1', '123'})
print(s)
s= dict((i,0) for i in frozenset({'n', 'o', 'h', ' ', '.', 'y', 't', 'P', '3'}))
print(s)
print("-------------访问集合-------------");
s = set(['A', 'B', 'C', 'D'])
# s = {'A', 'B', 'C', 'D'}
print('A' in s)
print('a' not in s)
for i in s:
print(i,end='\t')
print("-------------更新集合-------------");
s = set(['A', 'B', 'C', 'D'])
s = s|set('Python') # 使用操作符"|"
print(s)
s.add('ABC') # add()方法
print(s)
s.remove('ABC') # remove()方法
s.update('JAVAEF') # update()方法
print(s)
D:\工作空间\Python\venv\Scripts\python.exe D:/工作空间/Python/main.py
-------------创建集合-------------
set()
<class 'set'>
<class 'set'>
{1, '1', 'xyz', 'XYZ', '123', 'ABC'}
{0, 1, 2, 3, 4, 5, 6, 7, 8, 9}
frozenset({'t', 'o', 'y', 'n', '3', '.', 'h', ' ', 'P'})
{1: 0, '1': 0, 'xyz': 0, 'XYZ': 0, '123': 0, 'ABC': 0}
{'t': 0, 'o': 0, 'n': 0, '.': 0, 'y': 0, '3': 0, 'h': 0, ' ': 0, 'P': 0}
-------------访问集合-------------
True
True
B D C A -------------更新集合-------------
{'B', 't', 'o', 'y', 'n', 'D', 'C', 'h', 'P', 'A'}
{'B', 't', 'o', 'ABC', 'y', 'n', 'D', 'C', 'h', 'P', 'A'}
{'B', 'E', 't', 'o', 'y', 'n', 'J', 'D', 'C', 'h', 'F', 'P', 'V', 'A'}
进程已结束,退出代码0
D:\工作空间\Python\venv\Scripts\python.exe D:/工作空间/Python/main.py
-------------创建字典-------------
{}
{'id': 10, 'tel': 123456, 'name': '小明'}
-------------访问字典-------------
计算机
小明
-------------修改添加字典-------------
dict1['Age']: 18
dict1['college']: Tech
-------------删除字典-------------
{'stu_name': '小明', 'stu_age': 24}
{}
进程已结束,退出代码0
- 创建集合可使用 set( )和 frozenset( )函数，这两个函数分别用于创建可变集合和不可变集合
- 访问集合中的元素是指检查元素是否是集合中的成员，或通过遍历方法显示集合内的成员。
- 集合的更新包括增加、修改、删除集合的元素等。
- 集合所使用的标准类型操作符，包括成员关系（in 和 not in）、集合相等与不相等（==和!=）两种，判断集合是否同一集合可以通过比较集合是否相等来判断
- 集合类型专用操作符包括 4 个操作符：并操作符（|）、交操作符（&）、差补操作符（-）、对称差分操作符（^）
- 复合操作符，有 4 个。4 个复合操作符是集合类型专用符的 4 个操作符（|、&、-和^）分别与赋值符相结合构成增量赋值操作符，它们是：|=、&=、-= 和 ^=
函数
print("-------------定义函数-------------");
def print_info():
#打印提示信息，返回输入信息
print("欢迎访问学生信息管理系统，请按提示输入操作！")
print("1.添加学生信息")
print("2.删除学生信息")
print("3.修改学生信息")
print("4.查询学生信息")
print("5.浏览学生信息")
print("6.退出系统")
print("-------------调用函数-------------");
print_info()
D:\工作空间\Python\venv\Scripts\python.exe D:/工作空间/Python/main.py -------------定义函数------------- -------------调用函数------------- 欢迎访问学生信息管理系统，请按提示输入操作！ 1.添加学生信息 2.删除学生信息 3.修改学生信息 4.查询学生信息 5.浏览学生信息 6.退出系统 进程已结束,退出代码0
- 建立函数的一段程序（这段程序表达函数的功能）就是函数定义。在程序中使用这个函
数称调用这个函数。在程序中可以多次、反复地调用一个定义了的函数。函数必须先定义后
- 使用（调用）。定义一个由自己想要功能的函数，以下是简单的规则：
- 函数代码块以 def 关键词开头，后接函数标识符名称和圆括号（）。
- 函数的命名规则和对象变量相同，不能以数字开头，不得与关键字同名。
- 任何传入参数和自变量必须放在圆括号中间。圆括号之间可以用于定义参数。
- 函数的第一行语句可以选择性地使用文档字符串—用于存放函数说明。
- 函数内容以冒号起始，并且缩进。
- return[expression]结束函数，选择性地返回一个值给调用方。不带表达式的 return 相当于返回 None。
- 函数的定义格式为：
def <函数名>（<参数表>）：
<函数体>
return 表达式
- 定义一个函数时只给了函数一个名称，指定了函数里包含的参数和代码块结构。
- 函数只是一个代码块，本身是不会自动加载执行的，必须要有相关的调用。在面向对象的程序操作中，除了类默认主函数和构造函数，其他函数必须通过编写代码调用后方可执行。一般是程序函数的结构完成以后，通过另一个函数调用执行的。当然，也可以直接从 Python提示符执行。函数的调用方式很简单，通过“函数名（）”就可以完成调用。
- 函数调用有以下几种方式：【1】函数语句。函数调用单独出现，一般此时不需要函数的返回值，只是要把函数执行一遍完成函数的操作。【2】函数表达式。在表达式中调用函数，此时一般需要函数的返回值。这时函数的返回值被当作一个参与表达式运算的数据对象。【3】函数作参数。可以将函数调用得到的值作为其他函数调用的实际参数。
- 必备参数须以正确的顺序传入函数。调用时的参数个数必须和声明时的一样。
- 命名参数和函数调用关系紧密，调用方用参数的命名确定传入的参数值。Python 会跳过不传的参数或者乱序传参，因为 Python 解释器能够用参数名匹配参数值。
- 定义函数时，可以给函数的参数设置为默认值。也就是说，Python 中，对于形参，还可以使用默认值。如果函数定义中存在带有默认值的参数，该参数及其所有后续参数都是可选的。如果没有给函数定义中的所有可选参数赋值，就会引发 SyntaxError 异常。
- 如果需要一个函数能处理比当初声明时更多的参数，这些参数叫做不定长参数，和上述2 种参数不同，声明时前面需要添加*号
模块
- 导入模块使用 import 语句和 from…import 语句。导入方法有以下三种。
方法 1：import <库名>
方法 2：import <库名> as <新名字>
方法 3：from <库名> import <函数名>|
- 想使用 Python 源文件，只需在另一个源文件中执行 import 语句
- 使用 import math 导入数学模块，此时调用函数时，函数前面需要添加模块名，如 math.sqrt( )。如果模块名字比较长或名称可能重复，或不想直接使用模块名进行调用，这时可以使用 import… as…语句
- 有时候，需要在默认空间下直接使用某模块的相关函数，此时可以使用 from… import语句。
- from…import*语句可以导入模块的某些属性，也可以使用“from module import *”导入所有属性。
类和对象
类的创建
print("-------------创建类-------------");
class Stu:
name = "张三"
print(Stu.name)
D:\工作空间\Python\venv\Scripts\python.exe D:/工作空间/Python/main.py -------------创建类------------- 张三 进程已结束,退出代码0
- 在 Python 中，使用 class 语句来创建一个新类，class 之后为类的名称并以冒号结尾。类名使用驼峰（CamelCase）命名风格，首字母大写，私有类可用一个下画线开头
- 在 Python 中，有一些特殊的属性定义，主要是内置类属性。内置类属性包括以下几种。
__dict__：类的属性（包含一个字典，由类的数据属性组成）。
__doc__：类的文档字符串。
__name__：类名。
__module__：类定义所在的模块（类的全名是“__main__.className”，如果类位于一
个导入模块 mymod 中，那么 className.__module__ 等于 mymod）。
__bases__：类的所有父类构成元素（包含了由所有父类组成的元组）。
实例对象
print("-------------实例对象-------------");
class Stu:
# '定义一个属性
name = "张三"
age = 19
# 创建 Stu 类的对象
stu = Stu()
print("学生姓名:%s,年龄:%d" % (stu.name, stu.age))
D:\工作空间\Python\venv\Scripts\python.exe D:/工作空间/Python/main.py -------------实例对象------------- 学生姓名:张三,年龄:19 进程已结束,退出代码0
- 程序想要完成具体的功能，仅有类是不够的，需要根据类创建实例对象，通过实例对象完成具体的功能。
- 实例对象，就是为类创建一个具体的实例化的对象，以使用类的相关属性和方法。
- Python 中，创建类的实例化对象不需使用 new，可以直接赋值，语法如下：对象名=类名（）
类的方法
print("-------------构造方法------------");
class Stu:
# 构造方法
def __init__(self):
self.name = "张三"
self.stuid = 1
def displayCount(self):
print("学生姓名：%s，学号%d" % (self.name, self.stuid))
stu = Stu()
stu.displayCount()
print("-------------析构方法------------");
class Stu:
# 构造方法
def __init__(self, name, stuid):
self.name = name
self.stuid = stuid
# 析构方法
def __del__(self):
print("已释放资源")
stu = Stu("张三", 1)
del stu # 删除对象 触发析构方法
# del stu.name #这是属性的删除 不会触发,整个实例删除是才会触发
print("进行垃圾回收")
print("-------------封装------------");
# coding=utf-8
class JustCounter:
__secretCount = 0 # 私有变量
publicCount = 0 # 公开变量
def count(self):
self.__secretCount += 1
self.publicCount += 1
print(self.__secretCount)
counter = JustCounter()
counter.count()
counter.count()
print(counter.publicCount)
print(counter._JustCounter__secretCount)
D:\工作空间\Python\venv\Scripts\python.exe D:/工作空间/Python/main.py -------------构造方法------------ 学生姓名：张三，学号1 -------------析构方法------------ 已释放资源 进行垃圾回收 -------------封装------------ 1 2 2 2 进程已结束,退出代码0
- 构造方法__init__( )是一种特殊的方法，被称为类的构造函数或初始化方法，用来进行一些初始化的操作，在对象创建时就设置好属性。如果用户没有重新定义构造函数，则系统自动执行默认的构造方法。这个方法不需要显式调用，当创建了这个类的实例时就会调用该方法。在构造方法__init__( )中，init 前后用两个下画线开头和结尾，是 Python 内置的方法，用于在对象实例化时对实例进行的初始化工作。
- _init__( )方法是析构方法，当创建对象后，Python 解释器会调用__init__( )方法。当删除一个对象来释放类所占用的资源时，Python 解释器会调用另外一个方法，也就是析构方法。析构方法__del__( )，使用 del 命令，前后同样用两个下画线开头和结尾。该方法同样不需要显式调用，在释放对象时进行调用，可以进行释放资源的操作
- 面向对象编程的特性是封装、继承与多态。封装是隐藏属性、方法与方法实现细节的过程。封装是在变量或方法名前加两个下画线，封装后，私有的变量或方法只能在定义它们的类内部调用，在类外和子类中不能直接调用。
类的继承
print("-------------类的继承------------");
# coding=utf-8
class Parent: # 定义父类
parentAttr = 100
def __init__(self):
print("调用父类构造函数")
def parentMethod(self):
print("调用父类方法")
def setAttr(self, attr):
Parent.parentAttr = attr
def getAttr(self):
print("父类属性 :", Parent.parentAttr)
class Child(Parent): # 定义子类
def __init__(self):
print("调用子类构造方法")
def childMethod(self):
print("调用子类方法 child method")
c = Child() # 实例化子类
c.childMethod() # 调用子类的方法
c.parentMethod() # 调用父类方法
c.setAttr(200) # 再次调用父类的方法
c.getAttr() # 再次调用父类的方法
D:\工作空间\Python\venv\Scripts\python.exe D:/工作空间/Python/main.py -------------类的继承------------ 调用子类构造方法 调用子类方法 child method 调用父类方法 父类属性 : 200 进程已结束,退出代码0
- 继承语法“class 子类名(父类名):”也可写成“class 派生类名(基类名)：”，其中，父类名写在括号中，父类是在类定义时，在元组之中指明的。
- 在 Python 中继承具有如下一些特点：
【1】在继承中父类的构造（__init__( )方法）不会被自动调用，它需要在其子类的构造中亲自专门调用。
【2】在调用父类的方法时，需要加上父类的类名前缀，且需要带上 self 参数变量，以区别于在类中调用普通函数时并不需要带上 self 参数。
【3】Python 总是首先查找对应类型的方法，如果它不能在子类中找到对应的方法，它才到父类中逐个查找（先在本类中查找调用的方法，找不到才到父类中找）。
- 如果在继承元组中列了一个以上的类，那么它就被称为“多重继承”。子类的声明，与它们的父类类似，继承的父类列表跟在类名之后
方法重写
print("-------------方法重写------------");
# coding=utf-8
class Parent: # 定义父类
def myMethod(self):
print('调用父类方法')
class Child(Parent): # 定义子类
def myMethod(self):
print('调用子类方法')
c = Child() # 子类实例
c.myMethod() # 子类调用重写方法
D:\工作空间\Python\venv\Scripts\python.exe D:/工作空间/Python/main.py -------------方法重写------------ 调用子类方法 进程已结束,退出代码0
运算符重载
print("-------------运算符重载------------");
class Computation():
def __init__(self, value):
self.value = value
def __add__(self, other):
return self.value + other
def __sub__(self, other):
return self.value - other
c = Computation(5)
x = c + 5
print("重构后加法运算结果是：", x)
y = c - 3
print("重构后减法运算结果是：", y)
D:\工作空间\Python\venv\Scripts\python.exe D:/工作空间/Python/main.py -------------运算符重载------------ 重构后加法运算结果是： 10 重构后减法运算结果是： 2 进程已结束,退出代码0
- 类可以重载加减运算、打印、函数调用、索引等内置运算，运算符重载使我们的对象的行为与内置对象的一样。
文件处理
打开关闭文件
#在同一目录下新建文本文件 test.txt
f=open("test.txt","r")
print(type(f))
g=open("test.txt","rb")
print(type(g))
D:\工作空间\Python\venv\Scripts\python.exe D:/工作空间/Python/main.py <class '_io.TextIOWrapper'> <class '_io.BufferedReader'> 进程已结束,退出代码0
文件读写
#coding=utf-8
# 打开一个文件
f = open("f.txt", "w")
f.write( "人生苦短.\n 我用 Python!\n");
# 关闭打开的文件
f.close()
- 必须先用 Python 内置的 open( )函数打开一个文件，创建一个 file 对象，相关的辅助方法才可以调用它进行读写
- 一个文件被打开后，有一个 file 对象，可以得到有关该文件的各种信息。
- file.closed如果文件已被关闭返回True，否则返回False
- file.mode返回被打开文件的访问模式
- file.name返回文件的名称
- file.softspace如果用print输出后，必须跟-一个空格符，返回False，否则返回True
- file 对象的 close( )方法用于刷新缓冲区中任何还没写入的信息，并关闭该文件，这之后便不能再进行写入操作。
- 当一个文件对象的引用被重新指定给另一个文件时，Python 会关闭之前的文件。用 close( )方法关闭文件是一个很好的习惯
- 使用 with 语句，执行文件打开操作，实现预定义清理操作，文件在使用后将自动关闭，不再需要书写关闭文件代码。
- write( )方法可将任何字符串写入一个打开的文件中。需要重点注意的是，Python 字符串可以是二进制数据，而不仅仅是文字。write( )方法不在字符串的结尾添加换行符（'\n'）
- read( )方法从一个打开的文件中读取一个字符串
- tell( )方法用于告诉文件内的当前位置；换句话说，下一次的读写会发生在文件开头多字节之后。
- seek(offset [,from])方法用于改变当前文件的位置，其中，offset 变量表示要移动的字节数，from 变量指定开始移动字节的参考位置。
异常处理
异常
try:
f = open("test.txt", "w")
f.write("异常处理测试!")
except IOError:
print("错误: 没找到文件或文件不可用")
else:
print("读写成功")
f.close()
D:\工作空间\Python\venv\Scripts\python.exe D:/工作空间/Python/main.py 读写成功 进程已结束,退出代码0
- BaseException 和 ExceptionBaseException 是顶层的异常，Exception 是 BaseException 的下层异常。
- NameError这是企图访问一个未申明的变量而引发的 NameError。错误类型是：NameError：name '……' is not defined。
- ZeroDivisionError当除数为零时，会引发 ZeroDivisionError 异常。错误类型是：ZeroDivisionError：division by zero。
- SyntaxError程序代码中有语法错误，这种异常是非程序运行时的错误，只能在程序运行前纠错，也就是说，不可能用异常处理该错误。当解释器发现有语法错误时，会引发 SyntaxError 异常。错误类型是：SyntaxError：invalid syntax。
- IndexError请求的索引超出了序列范围，即当使用序列中不存在的索引时，会引发 IndexError 异常。错误类型是：IndexError：list index out of range。
- KeyError请求一个不存在的字典关键字。当使用映射中不存在的键时，会引发 KeyError 异常。错误类型是：KeyError：'server'。
- FileNotFoundError企图打开一个不存在的文件，会引发 FileNotFoundError。错误类型是：FileNotFoundError：[Errno 2] No such file or directory。
- AttributeError企图访问某对象的不存在的属性，即当尝试访问未知对象属性时，会引发 AttributeError异常。错误类型是：AttributeError："object has no attribute"。所有异常都是基类 Exception 的成员，它们都定义在 exceptions 模块中。
抛出异常
try:
raise IndexError
except:
print("出错了")
raise
D:\工作空间\Python\venv\Scripts\python.exe D:/工作空间/Python/main.py
Traceback (most recent call last):
File "D:/工作空间/Python/main.py", line 2, in <module>
raise IndexError
IndexError
出错了
进程已结束,退出代码1
raise 语句
Python 执行 raise 语句时，会引发异常并传递异常类的实例对象。使用 raise 语句能显式
地触发异常，分为三种情况进行处理。
（1）用类名引发异常，创建异常类的实例对象，并引发异常，基本格式如下：
raise 异常类名
raise 语句中，指定异常类名时，创建该类的实例对象，然后引发异常。使用时直接写出类名。例如：
raise IndexError
IndexError 是一个异常类，编码时不实例化，执行时会进行创建。
（2）用异常类实例对象引发异常，引发异常类实例对象对应的异常，基本格式如下：
raise 异常类对象
raise 语句中，使用异常类实例对象引发异常时，通过显式地创建异常类的实例，直接使用该实例来引发异常。例如：
index=IndexError()
raise index
（3）重新引发刚刚发生的异常，基本格式如下：
raise
此时，不带参数的 raise 语句，可以再次引发刚刚发生过的异常，作用就是向外传递异常。
这篇关于【合集】Python基础知识【第二版】的文章就介绍到这儿，希望我们推荐的文章对大家有所帮助，也希望大家多多支持为之网！
您可能喜欢
-
Python编程入门指南12-20
-
Python编程基础与进阶12-20
-
Python基础编程教程12-19
-
python 文件的后缀名是什么 怎么运行一个python文件？-icode9专业技术文章分享12-19
-
使用python 把docx转为pdf文件有哪些方法？-icode9专业技术文章分享12-19
-
python怎么更换换pip的源镜像？-icode9专业技术文章分享12-19
-
Python资料：新手入门的全面指南12-19
-
Python股票自动化交易实战入门教程12-19
-
Python股票自动化交易入门教程12-19
-
Python量化入门教程：轻松掌握量化交易基础知识12-18
-
Python股票自动化交易入门：初学者指南12-18
-
Python量化交易：新手入门教程12-18
-
Python入门：从零开始学习Python编程12-18
-
Python入门：轻松掌握Python编程基础12-18
-
Python编程入门指南12-18
栏目导航
