您的位置:首页 > 编程语言 > Python开发

【合集】Python基础知识【第二版】

2022-04-04 09:56 681 查看 https://www.cnblogs.com/yyyyfl

先前版本

【合集】Python基础知识【第一版】

更新部分

  1. 为了避免冗长的代码影响大家观感,将部分案例拆开
  2. 增加部分知识点,为了减少大家阅读的负担,尽可能使用短句子,但知识点不可能全覆盖,笔者不是写书,就算是写书也不可能全面,请同学们自行去补充
  3. 增加部分案例,但是目前笔者能力有限,大部分都是书上的案例直接拉过来,并且为了不影响观感案例不会太多,大部分为抛砖引玉,请同学们灵活变通

编程基础

基本输入输出

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
  1. 运行文件hello_world.py时,末尾的.py指出这是一个Python程序,因此编辑器将使用Python解释器来运行它
  2. 变量名只能包含字母、数字和下划线。变量名可以字母或下划线打头,但不能以数字打头,例如,可将变量命名为message_1,但不能将其命名为1_message。
  3. 变量名不能包含空格,但可使用下划线来分隔其中的单词。例如,变量名greeting_message可行,但变量名greeting message会引发错误。
  4. 不要将Python关键字和函数名用作变量名,即不要使用Python保留用于特殊用途的单词,
  5. 变量名应既简短又具有描述性。
  6. 慎用小写字母l和大写字母O,因为它们可能被人错看成数字1和0
  7. 在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
  1. 截取除法(//)的结果是整数,并且整数和浮点数均可应用。
  2. 除法(/):在 Python 2.X 中,如果操作数是整数,除法结果取整数,但在 Python 3.X中,结果是浮点数。
  3. 对浮点数来说,取余运算的结果是“a // b”的浮点数余数,即“a –(a//b)*b”。
  4. 对于复数,取余和截取除法是无效的。
  5. 对于比较运算符,可以有更复杂的写法,如:“a<b<c”,这相当于“a<b and b<c”,又如:“a<b>c”,相当于“a<b and b>c”,“a==b>c”相当于“a==b and b>c”。
  6. 不允许对复数进行比较。
  7. 只有当操作数是同一类型时,比较才有效。对于内置的数字对象,当两个操作数类型不一致时,Python 将进行类型的强制转换,例如,当操作数之一为浮点数时,则将另一个操作数也转换为浮点。
  8. not a:如果 a 为 False,则返回 1,否则返回 0。
  9. a and b:如果 a 为 False,则返回 a,否则返回 b。
  10. a or b:如果 a 为 False,则返回 b,否则返回 a。
  11. 身份运算符用 is、is not 表示,用于比较两个对象的存储单元。is not 是特殊的比较运算符,比较的是对象的存储单元,实际进行的是存储单元的比较。
  12. 存储单元地址可以使用函数 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
  1. 在Python中检查是否相等时区分大小写
  2. 要判断两个值是否不等,可结合使用惊叹号和等号( != )
  3. 要检查是否两个条件都为 True ,可使用关键字 and 将两个条件测试合而为一
  4. 关键字 or 也能够让你检查多个条件,但只要至少有一个条件满足,就能通过整个测试。
  5. 在 if 语句中,缩进的作用与 for 循环中相同。如果测试通过了,将执行 if 语句后面所有缩进的代码行,否则将忽略它们。
  6. 经常需要检查超过两个的情形,为此可使用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
  1. 函数 input() 让程序暂停运行,等待用户输入一些文本。获取用户输入后,Python将其存储在一个变量中,以方便你使用。
  2. 函数 input() 接受一个参数:即要向用户显示的提示或说明,让用户知道该如何做。
  3. 每当你使用函数 input() 时,都应指定清晰而易于明白的提示,准确地指出你希望用户提供什么样的信息——指出用户该输入任何信息的提示都行
  4. 使用函数 input() 时,Python将用户输入解读为字符串
  5. break 语句用来终止整个循环(当前循环),即循环条件没有为 False 或者序列还没被完全递归完,也会停止执行循环语句。
  6. break 语句用在 while 和 for 循环中。
  7. 如果使用嵌套循环,break 语句将停止执行当前的循环,并开始执行下一行代码。
  8. continue 语句用来跳出本次循环,而 break 语句用于跳出整个循环。
  9. continue 语句用来告诉 Python 跳过当前循环的剩余语句,然后继续进行下一轮循环。
  10. Python 的 pass 语句是空语句,是为了保持程序结构的完整性。pass 语句不做任何事情,一般作占位语句。
  11. 在 Python 中,while … else 表示这样的意思,while 中的语句和普通的没有区别,else中的语句会在循环正常执行完(即 while 语句不是通过 break 跳出而中断的)的情况下执。
  12. 在 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
  1. 字符串是 Python 中最常用的数据类型。我们可以使用引号来创建字符串。
  2. 字符串在内存中存储,每个字符都对应一个编号,常见的编号以 0 开始,依次加 1Python 的字符串列表有两种取值顺序:
  3. 从左到右索引默认是从 0 开始的,最大范围是字符串长度减去 1。
  4. 从右到左索引默认是从-1 开始的,最大范围是字符串开头。
  5. 如果要取得一段子串的话,用变量[头下标:尾下标]截取相应的字符串,其中下标是从 0开始算起的,可以是正数或负数,下标可以为空,表示取到头或尾。
  6. + 字符串连接 a + b 输出结果:HelloPython
  7. * 重复输出字符串 a*2 输出结果:HelloHello
  8. [] 通过索引获取字符串中字符 a[1] 输出结果 e
  9. [:] 截取字符串中的一部分 a[1:4] 输出结果 ell
  10. in 成员运算符,如果字符串中包含给定的字符则返回 True H in a 输出结果 1
  11. not in 成员运算符,如果字符串中不包含给定的字符则返回True M not in a 输出结果 1
  12. r/R 原始字符串,所有的字符串都是直接按照字面的意思来使用的,没有转义特殊或不能打印的字符。原始字符串除在字符串的第一个引号前加上字母“r”(可以大小写),与普通字符串有着几乎完全相同的语法
  13. % 格式字符串
  14. Python 不支持单字符类型,单字符在 Python 中也是作为一个字符串使用的,单字符的取值方式和字符串相同,只有一个下标值[0]。
  15. print( )函数可以采用格式化输出形式:print('格式串'%(对象 1,对象 2,...))
  16. 使用 format 格式化输出时,之前同样需要占位,不过此时不采用%占位符,而是采用{}占位,需要在什么位置插入相关数据,则在相关位置插入{}号
  17. 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
  1. 用方括号([])将一组 Python 对象括起来,Python 对象之间用逗号分隔。
  2. 列表操作符包括长度取值、连接、重复、成员检查和迭代检查。
  3. 使用下标索引来访问列表中的值,同样可以使用方括号的形式截取字符

元祖

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
  1. 创建元组与创建列表一样,只是其用圆括号而已。
  2. 访问元组的元素也是通过切片操作实施的,操作与列表一样。
  3. 元组中的元素值是不允许修改的
  4. 元组中的元素值是不允许删除的,但我们可以使用 del 语句来删除整个元组
  5. 与字符串一样,元组之间可以使用 + 号和 * 号进行运算。这就意味着它们可以组合和复制,运算后会生成一个新的元组
  6. 因为元组也是一个序列,所以我们可以访问元组中的指定位置的元素,也可以截取索引中的一段元素
  7. 任意无符号的对象,以逗号隔开,默认为元组
  8. 元组的不可变性带来的好处。元组的元素不可变,编写程序时,可以利用这个不可性保存数据,不被修改。因为元组不可变,所以元组可以作为字典的关键字使用。
  9. 和列表一样,元组也可以嵌套列表或元组。嵌套的子对象的可变性不受元组不可变的限制

字典

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
  1. 列表是有序的对象结合,字典是无序的对象集合。两者之间的区别在于:字典当中的元素是通过键来存取的,而不是通过顺序偏移存取。
  2. 字典用“{ }”标识。字典由索引(键 key)和它对应的值(value)组成。字典由键和对应值成对组成。字典也被称为关联数组或哈希表。
  3. 字典是键值对的无序集合。所谓键值对(又称条目、或元素)是指字典中的每个元素由键和值(又称数据项)两个部分组成,键是关键字,值是与关键字有关的数据。通过键可以找到与其有关的值,反过来则不行,不能通过值找键。
  4. 字典的定义是:在一对花括号({、})之间添加 0 个或多个元素,元素之间用逗号分隔;元素是键值对,键与值之间用冒号分隔;键必须是不可变对象,键在字典中必须是唯一的,值可以是不可变对象或可变对象。
  5. 键必须是不可变对象。这是说键必须是可哈希的,也就是说键可以通过哈希函数计算出对应值的存储位置。在字典中,通常将数字对象和字符串对象作为键,并将整数对象和浮点数对象作为同一个键,如整数 1 和浮点数 1.0 是同一个键。元组是不可变对象,原则上是可以作键使用的,但要求元组的元素是数字或字符串。
  6. 键在字典中必须是唯一的。如果有同名键存在,系统将用最后一个键值对取代前一个,以保证键的唯一性。
  7. 创建字典直接使用{}键入,用 dict( )函数创建字典,用 fromkeys( )方法创建字典。
  8. 访问字典里的值,格式简单,采用直接的访问方法,格式如下:<字典>[<键>]也就是“字典对象[key]”,key 如果是字符串,需要加引号;如果是数字,不能加引号。
  9. 字典中的元素都是以“键值对(key:value)”的方式存在的。在字典中,要想修改一个元素的值,可根据字典中的键名找到所对应的值,然后直接赋值即可。修改格式如下:字典["键名"]=值
  10. 可以删除单一的元素也可以清空字典。单一元素的删除操作:在字典中,元素是以一个键值对方式存在的,删除元素时,取键(key)即可,格式为:del 字典元素
  11. 不允许同一个键出现两次。创建时如果同一个键被赋值两次,后一个值会被记住,余下的将被抛弃
  12. 键必须不可变,可以用数、字符串或元组充当,但不能用列表或字典

集合

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
  1. 创建集合可使用 set( )和 frozenset( )函数,这两个函数分别用于创建可变集合和不可变集合
  2. 访问集合中的元素是指检查元素是否是集合中的成员,或通过遍历方法显示集合内的成员。
  3. 集合的更新包括增加、修改、删除集合的元素等。
  4. 集合所使用的标准类型操作符,包括成员关系(in 和 not in)、集合相等与不相等(==和!=)两种,判断集合是否同一集合可以通过比较集合是否相等来判断
  5. 集合类型专用操作符包括 4 个操作符:并操作符(|)、交操作符(&)、差补操作符(-)、对称差分操作符(^)
  6. 复合操作符,有 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
  1. 建立函数的一段程序(这段程序表达函数的功能)就是函数定义。在程序中使用这个函

数称调用这个函数。在程序中可以多次、反复地调用一个定义了的函数。函数必须先定义后

  1. 使用(调用)。定义一个由自己想要功能的函数,以下是简单的规则:
  2. 函数代码块以 def 关键词开头,后接函数标识符名称和圆括号()。
  3. 函数的命名规则和对象变量相同,不能以数字开头,不得与关键字同名。
  4. 任何传入参数和自变量必须放在圆括号中间。圆括号之间可以用于定义参数。
  5. 函数的第一行语句可以选择性地使用文档字符串—用于存放函数说明。
  6. 函数内容以冒号起始,并且缩进。
  7. return[expression]结束函数,选择性地返回一个值给调用方。不带表达式的 return 相当于返回 None。
  8. 函数的定义格式为:

def <函数名>(<参数表>):

<函数体>

return 表达式

  1. 定义一个函数时只给了函数一个名称,指定了函数里包含的参数和代码块结构。
  2. 函数只是一个代码块,本身是不会自动加载执行的,必须要有相关的调用。在面向对象的程序操作中,除了类默认主函数和构造函数,其他函数必须通过编写代码调用后方可执行。一般是程序函数的结构完成以后,通过另一个函数调用执行的。当然,也可以直接从 Python提示符执行。函数的调用方式很简单,通过“函数名()”就可以完成调用。
  3. 函数调用有以下几种方式:【1】函数语句。函数调用单独出现,一般此时不需要函数的返回值,只是要把函数执行一遍完成函数的操作。【2】函数表达式。在表达式中调用函数,此时一般需要函数的返回值。这时函数的返回值被当作一个参与表达式运算的数据对象。【3】函数作参数。可以将函数调用得到的值作为其他函数调用的实际参数。
  4. 必备参数须以正确的顺序传入函数。调用时的参数个数必须和声明时的一样。
  5. 命名参数和函数调用关系紧密,调用方用参数的命名确定传入的参数值。Python 会跳过不传的参数或者乱序传参,因为 Python 解释器能够用参数名匹配参数值。
  6. 定义函数时,可以给函数的参数设置为默认值。也就是说,Python 中,对于形参,还可以使用默认值。如果函数定义中存在带有默认值的参数,该参数及其所有后续参数都是可选的。如果没有给函数定义中的所有可选参数赋值,就会引发 SyntaxError 异常。
  7. 如果需要一个函数能处理比当初声明时更多的参数,这些参数叫做不定长参数,和上述2 种参数不同,声明时前面需要添加*号

模块

  1. 导入模块使用 import 语句和 from…import 语句。导入方法有以下三种。

方法 1:import <库名>

方法 2:import <库名> as <新名字>

方法 3:from <库名> import <函数名>|

  1. 想使用 Python 源文件,只需在另一个源文件中执行 import 语句
  2. 使用 import math 导入数学模块,此时调用函数时,函数前面需要添加模块名,如 math.sqrt( )。如果模块名字比较长或名称可能重复,或不想直接使用模块名进行调用,这时可以使用 import… as…语句
  3. 有时候,需要在默认空间下直接使用某模块的相关函数,此时可以使用 from… import语句。
  4. from…import*语句可以导入模块的某些属性,也可以使用“from module import *”导入所有属性。

类和对象

类的创建

print("-------------创建类-------------");

class Stu:
name = "张三"

print(Stu.name)
D:\工作空间\Python\venv\Scripts\python.exe D:/工作空间/Python/main.py
-------------创建类-------------
张三

进程已结束,退出代码0
  1. 在 Python 中,使用 class 语句来创建一个新类,class 之后为类的名称并以冒号结尾。类名使用驼峰(CamelCase)命名风格,首字母大写,私有类可用一个下画线开头
  2. 在 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
  1. 程序想要完成具体的功能,仅有类是不够的,需要根据类创建实例对象,通过实例对象完成具体的功能。
  2. 实例对象,就是为类创建一个具体的实例化的对象,以使用类的相关属性和方法。
  3. 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
  1. 构造方法__init__( )是一种特殊的方法,被称为类的构造函数或初始化方法,用来进行一些初始化的操作,在对象创建时就设置好属性。如果用户没有重新定义构造函数,则系统自动执行默认的构造方法。这个方法不需要显式调用,当创建了这个类的实例时就会调用该方法。在构造方法__init__( )中,init 前后用两个下画线开头和结尾,是 Python 内置的方法,用于在对象实例化时对实例进行的初始化工作。
  2. _init__( )方法是析构方法,当创建对象后,Python 解释器会调用__init__( )方法。当删除一个对象来释放类所占用的资源时,Python 解释器会调用另外一个方法,也就是析构方法。析构方法__del__( ),使用 del 命令,前后同样用两个下画线开头和结尾。该方法同样不需要显式调用,在释放对象时进行调用,可以进行释放资源的操作
  3. 面向对象编程的特性是封装、继承与多态。封装是隐藏属性、方法与方法实现细节的过程。封装是在变量或方法名前加两个下画线,封装后,私有的变量或方法只能在定义它们的类内部调用,在类外和子类中不能直接调用。

类的继承

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
  1. 继承语法“class 子类名(父类名):”也可写成“class 派生类名(基类名):”,其中,父类名写在括号中,父类是在类定义时,在元组之中指明的。
  2. 在 Python 中继承具有如下一些特点:

【1】在继承中父类的构造(__init__( )方法)不会被自动调用,它需要在其子类的构造中亲自专门调用。

【2】在调用父类的方法时,需要加上父类的类名前缀,且需要带上 self 参数变量,以区别于在类中调用普通函数时并不需要带上 self 参数。

【3】Python 总是首先查找对应类型的方法,如果它不能在子类中找到对应的方法,它才到父类中逐个查找(先在本类中查找调用的方法,找不到才到父类中找)。

  1. 如果在继承元组中列了一个以上的类,那么它就被称为“多重继承”。子类的声明,与它们的父类类似,继承的父类列表跟在类名之后

方法重写

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
  1. 类可以重载加减运算、打印、函数调用、索引等内置运算,运算符重载使我们的对象的行为与内置对象的一样。

文件处理

打开关闭文件

#在同一目录下新建文本文件 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()

  1. 必须先用 Python 内置的 open( )函数打开一个文件,创建一个 file 对象,相关的辅助方法才可以调用它进行读写
  2. 一个文件被打开后,有一个 file 对象,可以得到有关该文件的各种信息。
  3. file.closed如果文件已被关闭返回True,否则返回False
  4. file.mode返回被打开文件的访问模式
  5. file.name返回文件的名称
  6. file.softspace如果用print输出后,必须跟-一个空格符,返回False,否则返回True
  7. file 对象的 close( )方法用于刷新缓冲区中任何还没写入的信息,并关闭该文件,这之后便不能再进行写入操作。
  8. 当一个文件对象的引用被重新指定给另一个文件时,Python 会关闭之前的文件。用 close( )方法关闭文件是一个很好的习惯
  9. 使用 with 语句,执行文件打开操作,实现预定义清理操作,文件在使用后将自动关闭,不再需要书写关闭文件代码。
  10. write( )方法可将任何字符串写入一个打开的文件中。需要重点注意的是,Python 字符串可以是二进制数据,而不仅仅是文字。write( )方法不在字符串的结尾添加换行符('\n')
  11. read( )方法从一个打开的文件中读取一个字符串
  12. tell( )方法用于告诉文件内的当前位置;换句话说,下一次的读写会发生在文件开头多字节之后。
  13. 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
  1. BaseException 和 ExceptionBaseException 是顶层的异常,Exception 是 BaseException 的下层异常。
  2. NameError这是企图访问一个未申明的变量而引发的 NameError。错误类型是:NameError:name '……' is not defined。
  3. ZeroDivisionError当除数为零时,会引发 ZeroDivisionError 异常。错误类型是:ZeroDivisionError:division by zero。
  4. SyntaxError程序代码中有语法错误,这种异常是非程序运行时的错误,只能在程序运行前纠错,也就是说,不可能用异常处理该错误。当解释器发现有语法错误时,会引发 SyntaxError 异常。错误类型是:SyntaxError:invalid syntax。
  5. IndexError请求的索引超出了序列范围,即当使用序列中不存在的索引时,会引发 IndexError 异常。错误类型是:IndexError:list index out of range。
  6. KeyError请求一个不存在的字典关键字。当使用映射中不存在的键时,会引发 KeyError 异常。错误类型是:KeyError:'server'。
  7. FileNotFoundError企图打开一个不存在的文件,会引发 FileNotFoundError。错误类型是:FileNotFoundError:[Errno 2] No such file or directory。
  8. 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 语句,可以再次引发刚刚发生过的异常,作用就是向外传递异常。

内容来自用户分享和网络整理,不保证内容的准确性,如有侵权内容,可联系管理员处理 点击这里给我发消息
标签: