历史版本

【合集】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基础知识【第二版】

必须先用 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 语句，可以再次引发刚刚发生过的异常，作用就是向外传递异常。

在黑夜里梦想着光，心中覆盖悲伤，在悲伤里忍受孤独，空守一丝温暖。
我的泪水是无底深海，对你的爱已无言，相信无尽的力量，那是真爱永在。
我的信仰是无底深海，澎湃着心中火焰，燃烧无尽的力量，那是忠诚永在

来源：https://www.cnblogs.com/yyyyfly1/p/16098319.html
本站部分图文来源于网络，如有侵权请联系删除。