python 入门知识点

我们在入门python的时候，经常知道思路，但是却找不到合适的方法来处理。这里小编搜集了好几本python入门教程，尽可能将里面的一些基础性的知识点整理了出来，特在此将此分享给大家，供大家查阅。

注意：由于本人的个人习惯，为了使代码更加清晰明了，将采取以下方式呈现代码，诸位在学习敲代码时注意将前面的>>>去掉

>>> 代码部分
>>> 代码部分
输出部分

注意：看不懂的部分可以去第12节寻找答案

一、Python

1.1 Python简介

Python是一种高级编程语言，由Guido van Rossum于1989年开始开发，并于1991年首次发布。它是一种通用的、解释型的编程语言，具有简洁、可读性强的语法和丰富的标准库。Python以其易学易用、可移植性强以及广泛的应用领域而闻名。

Python拥有动态类型系统和自动内存管理，可以在多个平台上运行，包括Windows、Mac和Linux。它支持面向对象、函数式和过程式编程范式，同时提供了各种功能强大的库和工具，用于处理文本、图像、数据分析、Web开发、人工智能等各种领域。

Python的语法简洁明了，注重可读性，这使得它成为初学者入门编程的理想选择。同时，由于Python社区活跃和庞大，开发者可以很容易地找到支持和解决问题的资源。

总体而言，Python是一门功能强大、灵活多样的编程语言，适用于各种不同规模和领域的项目开发。

1.2 Python下载及解释器

pycharm官网:PyCharm: the Python IDE for Professional Developers by JetBrains

pycharm专业版版学生申请教程:pycharm专业版激活

anaconda下载镜像源:

清华大学 ：https://pypi.tuna.tsinghua.edu.cn/simple/
阿里云：http://mirrors.aliyun.com/pypi/simple/
中国科学技术大学 ：http://pypi.mirrors.ustc.edu.cn/simple/
华中科技大学：http://pypi.hustunique.com/
豆瓣源：http://pypi.douban.com/simple/
腾讯源：http://mirrors.cloud.tencent.com/pypi/simple
华为镜像源：https://repo.huaweicloud.com/repository/pypi/simple/

安装anaconda教程:

Anaconda安装(Windows系统)

[Anaconda安装(Mac系统)](https://blog.csdn.net/qq_38262728/article/details/85254546?ops_request_misc=%7B%22request%5Fid%22%3A%22169372993216777224494571%22%2C%22scm%22%3A%2220140713.130102334…%22%7D&request_id=169372993216777224494571&biz_id=0&utm_medium=distribute.pc_search_result.none-task-blog-2_allsobaiduend~default-2-85254546-null-null.142^v93chatsearchT3_1&utm_term= Macbook anaconda下载&spm=1018.2226.3001.4187)

二、六种数据类型及之间的相互转换

2.1 六种数据类型

数据类型	名称
number	数字
string	字符串
list	列表
tuple	元组
dictionary	字典
set	集合

其中number（数字）中包含3种数值类型：
1.整型（int）
整型就是整数，包括正整数、负整数、零，不带小数点。
2.浮点型（float）
浮点型由整数部分与小数点组成，必须包含小数点。
3.布尔型（bool）
布尔型是一种表示逻辑值的简单类型，只有俩个值，一个为 True（真，1），另一个为False（假，0）。
注意：如果不知道某一变量的数据类型是什么，可以通过type()函数查询

>>>a = []
>>>print(type(a))
<class 'list'>

2.2 相互转换

函数	描述
int(x)	将x转换为一个整数
float(x)	将x转换为一个浮点数
str(x/s)	将x/s转换为字符串
eval(str)	用于字符串，去除字符串的引号，获取引号里面的内容
list(s)	将序列s转换为一个列表
tuple(s)	将序列s转换为一个元组
set(s)	将序列s转换为一个集合
dict(d)	创建一个字典，d必须是一个(key,value)元组序列

三、运算符

3.1 运算符

运算符分为算术运算符，赋值运算符和比较运算符
其中的优先级为：

1.**
2.算术运算符： * / % // + -
3.比较运算符：<= < > >= == !=
4.赋值运算符：= %= /= //= -= += *= **=

算术运算符 > 比较运算符 > 赋值运算符

3.2 算术运算符

运算符	意义	例子
+	两个数相加	a+b
-	两个数相减	a-b
*	两个数相乘	a*b
/	两个数相除，结果为浮点数（小数）	a/b
//	两个数相除，结果为向下取整数	a//b
%	取模，返回两个数相除的余数	a%b
**	幂运算，返回乘方结果	a**b

注意：
1.将任意两个数相除时，结果总是浮点数，即使这两个数都是整数且能整除。

>>>a = 4
>>>print(a/2) 
2.0

2.在其他任何运算中，如果一个数是整数，另一个数是浮点数，结果也是浮点数。

>>>a = 1
>>>b = a + 2.0
>>>print(b)
3.0

3.2 比较运算符

运算符	意义	例子
=	常规赋值运算符	a=b
+=	加法赋值运算符	a+=b(a=a+b)
-=	减法赋值运算符	a-=b(a=a-b)
*=	乘法赋值运算符	a*=b(a=a*b)
/=	除法赋值运算符	a/=b(a=a/b)
//=	取整除赋值运算符	a//=b(a=a//b)
%=	取模赋值运算符	a%=b(a=a%b)
**=	幂运算赋值运算符	a=b(a=ab)

3.3 赋值运算符

运算符	意义	例子
==	比较两个对象是否相等	a==b
!=	比较两个对象是否不相等	a!=b
>	大于（大小比较）	a>b
<	小于（大小比较）	a<b
>=	大于等于（大小比较）	a>=b
<=	小于等于（大小比较）	a<=b

3.4 逻辑运算符

运算符	意义	例子
and	“与”运算符，一假为假，全真为真	a and b
or	“或”运算符，一真为真，全假为假	a or b
not	“非”运算符，为真则假，为假则真	not a not(a and b)

注意：Python中的and和&有区别，不能混用

and：逻辑运算符。比如加减乘除符号有各自对用的运算规则，作为逻辑运算符也得遵守相应的规则。

&：位运算符，是按位进行逻辑运算，将操作数转化为对应的的二进制进行逻辑运算，运算结果再转化为原来的进制。

四、判断语句

判断语句句法

1.if 判断条件 :
	语句
2.if 判断条件：
	语句
   else：
	语句
3.if 判断条件：
	语句
  elif 判断条件：
	语句
   	……
  else：
	语句

例如：定义一个整数变量age，编写代码判断输入的年龄是否正确。要求人的年龄在0-120之间。

age = int(input())
if age > 120:
    print("年龄太高,输入错误！")
elif age > 70:
    print("老年人")
elif age > 40:
    print("壮年")
elif age > 16:
    print("青年")
elif age > 0:
    print("儿童")
else:
    print("该人不存在！！")

注意:Python里面没有switch语句！！

五、循环语句

循环语句主要分为while语句和for语句

5.1 while 语句

while语句由三部分组成：
1.while
2.条件表达式和冒号
3.当条件表达式结果为真时要执行的循环体

while语句句法：

while 表达式:
	循环体

5.2 for循环

for语句句法：

for 循环变量 in 遍历对象(序列)：
	循环体

for 循环，从形式上可以分为俩种：
1.遍历对象
2.使用range函数控制循环次数
range函数:
range(起始值，终止值，步长)
步长 ：每次循环序列增长值，默认值为1，为1时可以省略
例如：输出1-10内所有的奇数和偶数

>>>#使用while循环
>>>i = 1
>>>while i <= 10:
>>>    if i % 2 == 0:
>>>        print(f"偶数：{i}")
>>>    if i % 2 == 1:
>>>        print(f"奇数：{i}")
>>>    i += 1
奇数：1
偶数：2
奇数：3
偶数：4
奇数：5
偶数：6
奇数：7
偶数：8
奇数：9
偶数：10
>>>#使用for循环
>>>for i in range(1,11):
>>>    if i % 2 == 0:
>>>        print(f"偶数：{i}")
>>>    if i % 2 == 1:
>>>        print(f"奇数：{i}")
奇数：1
偶数：2
奇数：3
偶数：4
奇数：5
偶数：6
奇数：7
偶数：8
奇数：9
偶数：10

六、字符串

6.1 转义字符

转义字符	输出为
\'	'
\"	"
\t	制表符
\n	换行符
\\	倒斜杠

6.2 字符串的索引、切片与逆序

"Hello , world!"这个字符串中有13个字符(字符串的计数包含空格和符号)
注意：索引从0开始

H  e  l  l  o  ,     w  o  r  l  d   !
0  1  2  3  4  5  6  7  8  9 10  11  12

H的索引就是0，!的索引就是12
首先，我们需要定义一个变量a使它=“Hello , world!”
获取单个字符w时可以使用变量名[索引]

>>>a = "Hello , world!"
>>>print(a[7])
w

如果此时我们只想获得world这个字符串，那么可以使用切片
切片时我们可以使用变量名[起始索引:结束索引+1:间隔个数]
起始索引默认为0，结束索引默认为最后，间隔个数默认为1，若为默认时可以省略

>>>a = "Hello , world!"
>>>print(a[7:12])
world
>>>print(a[7:12:2])
wrd

此时我们想要逆序输出world,即输出"dlrow"
只需要使用变量名[结束索引:开始索引-1：-1]

>>>a = "Hello , world!"
>>>print(a[11:6:-1])
dlrow
>>>print(a[11:6:-2])
drw

注意：为什么是结束索引+1和开始索引-1？
Python中所有的区间都是左闭右开的，所以右边的数取不到，要想取到右边的数只有将右边的数向右再延伸一个即加一。至于为何逆序就要减一，你可以把字符串反过来看，即

！  d  l  r  o  w     ,  o  l  l  e  H
12 11  10 9  8  7  6  5  4  3  2  1  0

同样是从d开始切片，切到w结束，按照左闭右开，需要再往右延伸一个，即减一。

6.3 字符串的连接

使用"+"连接

>>>a = "Hello "
>>>b = "world" 
>>>print(a+b)
Hello world
>>>name = "xiaobian" 
>>>age = 18
>>>print("My name is " + name +".I am "+ str(age) + " years old.")
My name is xiaobian.I am 18 years old.

注意：str（age）这里需要将age转换成字符串，否则系统会报错，此时age是整型不能与字符串同时输出。

6.4 字符串方法

方法	代码示范	作用
upper()	字符串.upper()	将字符串里的字符全部大写
lower()	字符串.lower()	将字符串里的字符全部小写
isupper()	字符串.isupper()	字符串中字符是否都是由大写字母组成
islower()	字符串.islower()	字符串中字符是否都是由小写字母组成
isdigit()	字符串.isdigit()	字符串中是否都是由数字组成
isnumeric()	字符串.isnumeric()	字符串中字符是否都是由数字字符组成
isalpha()	字符串.isalpha()	字符串中是否都是由字母组成，并且非空
isalnum()	字符串.isalnum()	字符串中是否都是由字母和数字组成，并且非空
isdecimal()	字符串.isdecimal()	字符串中是否都是由数字字符组成，并且非空
isspace()	字符串.isspace()	字符串中是否都是由空格、制表符和换行符组成，并且非空
istitle()	字符串.istitle()	字符串中是否以大写字母开头、后面都是小写字母的单词、数字或空格
find()	字符串.find(字符,起始位置,结束位置)	查找指定字符在字符串中的位置（索引）(找不到则返回-1)
index()	字符串.index(字符,起始位置,结束位置)	查找指定字符在字符串中的位置（索引）(找不到会报错)
count()	字符串.count(字符)	统计指定字符出现的次数
replace()	字符串.replace(字符,新字符,替换次数)	用于字符串的修改
split()	字符串.split(分隔符，分割次数)	拆分字符串。通过指定分隔符对字符串进行切片，并返回分割后的字符串列表。
join()	分隔符.join(序列)	返回一个用分隔符连接序列各个元素后的字符串（注：分隔符可以为空）
title()	字符串.title()	字符串内的所有单词的首字母大写
capittalize()	字符串.capittalize()	字符串第一个字母大写
startswith()	字符串1.startswith(字符串2)	字符串2是否以字符串开始
endswith()	字符串1.endswith(字符串2)	字符串2是否以字符串结束
partition()	字符串.partition(字符串中片段)	以字符串中片段为分隔符分隔字符串
rjust()	字符串.rjust(数字,‘填充字符’)	右对齐字符串，左边填充上‘填充字符’，总字符长度为‘数字’
ljust()	字符串.ljust(数字,‘填充字符’)	左对齐字符串，右边填充上‘填充字符’，总字符长度为‘数字’
center()	字符串.center(数字,‘填充字符’)	字符串居中，两边填充上‘填充字符’，总字符长度为‘数字’
strip()	字符串.strip(空格、制表符、换行符和字符串参数)	删除字符串两边所选字符
rstrip()	字符串.rstrip(空格、制表符、换行符和字符串参数)	删除字符串右边所选字符
lstrip()	字符串.lstrip(空格、制表符、换行符和字符串参数)	删除字符串左边所选字符

注意：作用中有关是否的方法中，若符合则返回True，不符合则返回False

6.5 使用ord()和chr()函数的字符的数值

ord(字符)获取一个单字符字符串的代码点
chr(代码点)获取一个整数代码点的单字符字符串

七、列表

7.1 列表操作

列表操作	代码示范
创建一个空列表	a = [ ]
访问列表中的某个元素	a[索引]
访问列表的最后一个元素	a[-1]

看到这里是不是发觉与字符串的索引很像，的确他们的形式是一样的。
以此类推，列表的切片和逆序与字符串格式一致，也是a[ : : ]和a[ : :-1],同时别忘记逆序时开始索引与结束索引的位置。

7.2 列表方法

操作	代码示范	描述
增	列表.append(元素)	在列表末尾添加一个元素
增	列表.extend(序列)	在列表末尾追加一个序列
增	列表.insert(索引，元素)	在列表对应的索引插入元素
删	del 列表[索引]	删除列表中对应索引的元素
删	列表.pop(索引)	删除列表中对应索引的元素，并返回删除的元素，默认最后一个
删	列表.remove(元素)	删除列表中对应元素的第一个匹配项
删	列表.clear()	清空列表
改	列表[索引]=新元素	将列表对应索引的元素，修改为新元素
查	列表.index(元素)	返回元素对应的索引

7.3 列表推导式

[表达式 for 变量 in 列表]
[表达式 for 变量 in 列表 if 条件]
例如：输出列表，里面包括从1-20
输出列表，里面包括1-20中所有偶数

>>>a = [x for x in range(1,21)]
>>>print(a)
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20]
>>>b = [x for x in range(1,21) if x%2 == 0]
>>>print(b)
[2, 4, 6, 8, 10, 12, 14, 16, 18, 20]

7.4 列表函数

7.4.1 len()函数

len()函数可以取得列表的长度

>>>a = [11,22,33,44,55]
>>>print(len(a))
5

7.4.2 连接与复制

像字符串一样，+操作符可以连接两个列表，得到一个新的列表；*操作符可以用于一个列表和一个整数，实现列表的复制

>>>a = [1,2,3]
>>>b = ['A','B','C']
>>>print(a+b)
>>>print(a*3)
[1, 2, 3, 'A', 'B', 'C']
[1, 2, 3, 1, 2, 3, 1, 2, 3]

7.4.3 sum()函数

sum()函数可以将列表中所有数相加

>>>a = [11,22,33]
>>>print(sum(a))
66

7.4.4 enumerate()函数

在for循环中迭代，每次enumerate()函数将返回两个值：列表表项的索引和列表表项本身。

7.4.5 random.choice()和random.shuffle()函数

random.choice()函数将从列表中返回一个随机选择的表项。

random.shuffle()函数将对列表中的表项重新排序。该函数将就地修改列表，而不是返回新列表。**

7.4.6 排序

1.sort()：可以对列表进行永久排序

​ 列表.sort(reverse=True/False)

2.sorted()可以对列表进行临时排序

​ sorted(列表名,reverse=True/False)

reverse=True 时，按降序排序。

reverse=False 时，按升序排序。

7.4.7 多重赋值

使用多重赋值是一种快捷方式，在一行代码中，用列表中的值为多个变量赋值。
所以，不用输入以下代码

>>>cat = ['fat','black','loud']
>>>size = cat[0]
>>>color = cat[1]
>>>disposition = cat[2]

而是通过以下代码实现

>>>cat = ['fat','black','loud']
>>>size,color,disposition = cat

八、 元组

8.1 元组操作

列表操作	代码示范
创建一个空元组	a =（）
创建包含一个元素的元组	b =（元素,）
创建元组	c =（元素1,元素2,……）

注意：包含一个元素的元组必须有逗号

8.2 元组的访问

获取一个元素	元组序列[所有]
获取多个连接的元素	元组序列[开始索引,结束索引]

注意：元组是不可以修改的，包括不能删除其中的元素。元组内的直接数据如果修改则立即报错。但是，如果元组里面有列表，修改列表里面的数据不会报错。

8.3 元组的操作

操作	作用
index()	从元组中找出某个对象第一个匹配项的下标位置。
count()	统计某个元素在元组中出现的次数
len()	计数元组元素的个数，并返回值
max()	返回元组中元素的最大值
min()	返回元组中元素的最小值

注意：元组除了两个方面，元组的数据类型几乎和列表数据类型一样：
1.元组输入时用圆括号(),不是方括号[ ]
2.元组的值无法修改、添加或删除。

九、字典

9.1 字典操作

字典操作	代码示范
创建空字典	dict1 = {}/dict2 = dict()
创建字典	dict3 = { 键1 :值1 ,键2: 值2,……}

例如：dict3 = {‘name’: ‘小编’, ‘age’: 18}

9.2 特点

1.符号为大括号{}
2.数据为键值对形式出现
3.各个键值对之间用逗号隔开

9.3 字典方法

9.3.1 字典访问

操作	代码示范	描述
访问值	字典序列[键]	访问已知键所对应的值
修改值	字典序列[键]=新值	修改已知键的值
添加键值对	字典序列[新键]=新值	添加新的键值对
删	del 字典序列[键]	删除字典中对应的键的键值对
删	del 字典序列	删除字典
删	字典序列.clear()	清空字典
查	字典序列.items()	查找字典的所有的键值对
查	字典序列.keys()	查找字典的所有的key(键)
查	字典序列.values()	查找字典的所有的value(值)

9.3.2 使用enumerate()函数枚举键值对

enumerate(序列, start=0)
其中start = 0为默认开始值为0

9.3.3 get()方法

get()方法有两个参数，分别为要取得其值的键，以及当该键不存在时返回的备用值。

>>>a = {'apple':2,'banana':3}
>>>print('I have '+str(a.get('orange',0))+' oranges.')
I have 0 oranges.
>>>print('I have '+str(a.get('apple',0))+' apples.')
I have 2 apples.

9.3.4 setdefault()方法

你常常需要为字典中的某个键设置一个默认值，当该键没有任何值时使用它。
而 setdefault()方法提供了一种方式，可以在一行中完成这件事。传递给该方法的第一个参数是要检查的键，第二个参数是当该键不存在时要设置的值。如果该键存在，那么 setdefault()方法就会返回键的值

>>>a = {'apple':2,'banana':3}
>>>print(a.setdefault('orange',10))
10
>>>print(a.setdefault('apple',10))
2

十、集合

可以使用大括号 { } 或者 set() 函数创建集合，但创建一个空集合必须用 set() 而不是 { }，因为 { } 是用来创建一个空字典。

集合特点：
1.集合是一个无序的不重复元素序列
2.集合中的元素是唯一的
3.集合可以用来去重

10.1 集合操作

操作	代码示范	描述
增	集合序列.add(数据)	添加一个数据
增	集合序列.update(序列数据)	添加序列
删	集合序列.remove(数据)	删除集合中指定的数据，如果数据不存在就报错
删	集合序列.pop()	随机删除集合中的某个数据
删	集合序列.discard(数据)	删除集合中指定的数据，如果数据不存在不做任何操作

十一、 函数

11.1 函数简介

如果在开发程序时，需要某块代码多次，为了提高编写的效率以及代码的重用，就把具有独立功能的代码块组织为一个小模块，这一个小模块就是函数。

作用:
1.减少代码的重复性。
2.使代码可读性更好。

#定义函数语法：
def 函数名 ( ):
	函数语句
#调用函数语法：
函数名( )

注意：1.函数先定义后调用，如果先调用会报错。
2.函数没有被调用时，函数里面的执行语句不会被执行。

11.2 返回值

函数并非总是直接显示输出，有时也可以处理一些数据，再返回处理好的数据。函数返回的数据称为返回值。
语法：
def 函数名 ( ):
[][]函数语句
[][]return 返回值
注意：函数中可以同时包含多个 return 语句，但只会执行了一个return,return的功能是返回值并退出当前函数，return语句后面的语句都不执行。

11.3 形参和实参

#定义格式:
def 函数名(形参1,形参2):
    函数体
#调用格式:
函数名(实参1,实参2)  

注意：

1.传递的实参与形参个数必须保持一致，否则将发生参数不匹配错误。
2.编写函数时可给每个形参指定默认值，调用函数时给形参提供实参的，将使用指定的实参，若没有则使用默认值。
3.调用函数时，会将实参1传递给形参1，实参2传递给形参2，……如果参数位置不对，可能达不到预期效果，如果参数过多时可以在调用函数时直接指明形参1=实参1

>>>def people(name,age):
>>>		print(f'My name is  {name}.I am {age} years old.')
>>>people('xiaobian',18)
My name is  xiaobian.I am 18 years old.
>>>people(age =18,name='xiaobian')
My name is  xiaobian.I am 18 years old.

11.4 参数

参数分为三种：
1.位置参数(必备参数)

2.默认参数(缺省参数)

3.不定长参数(*args,kwargs)
*args常以元组的形式输出，收集任意数量的位置实参
kwargs常以字典的形式输出，收集任意数量的关键字实参

11.4.1 位置参数

def 函数名(形参1,形参2):
	函数体
函数名(实参1，实参2)

11.4.2 默认参数

def 函数名(形参1=数据,…):
	函数体

11.4.3 不定长参数

*不定长参数(args)

def 函数名(*args):
	函数体
函数名(实参1，实参2，实参3,……)

不定长参数(kwargs)

def 函数名(kwargs):
	函数体

11.4.4 参数定义顺序：

位置参数、默认参数、不定长参数(*args,kwargs)

11.5 作用域

变量作用域就是指变量的作用范围，在什么范围内起作用。
变量作用域主要分为局部作用域和全局作用域**。**

11.5.1 局部作用域

定义在函数内部的变量拥有一个局部作用域，表示只能在声明它的函数内部访问。在函数体内部，临时保存数据，即当函数调用完成后，则销毁局部变量。

11.5.2 全局作用域

定义在函数外部的变量拥有全局作用域，表示可以在整个程序范围内访问（函数内、外部都能生效）。

11.5.3 修改作用域

global	nonlocal
声明变量的作用域为全局作用域	数中的下划线关键字用来在函数中使用外层(非全局)变量

>>>def great():
>>>    global a  
>>>    a = 40
>>>    print(f'函数内：{a}')
>>>a = 20
>>>great()
>>>print(f'函数外：{a}')
函数内：40
函数外：40

>>>def outer():
>>>    num = 10
>>>    print(f'outer1：{num}')
>>>    def inner():
>>>        nonlocal num
>>>        num = 20
>>>        print(f'inner: {num}')
>>>    inner()
>>>    print(f'outer2：{num}')
>>>outer()
outer1：10
inner: 20
outer2：20

十二、基础必备知识

12.1 数中的下划线

书写很大的数时，也可以使用下划线将其中的数字分组，使其更清楚易读

>>> a = 100_000_000_000
>>> print(a)
100000000000

12.2 常量

常量类似于变量，其值在整个生命周期内不变，一般用全部大写字母表示某个量是常量。

MAX_RMB_PAR_VALUE = 100

12.3 注释

井号字符（#）只能单行注释
多行字符串（三重引号）可以多行注释

>>>'''
>>>我所记得的故乡全不如此。我的故乡好得多了。
>>>但要我记起他的美丽，说出他的佳处来，却又没有影像，没有言辞了。
>>>仿佛也就如此。于是我自己解释说：故乡本也如此，
>>>——虽然没有进步，也未必有如我所感的悲凉，这只是我自己心情的改变罢了，
>>>因为我这次回乡，本没有什么好心绪。
>>>'''
>>>#print("因为我这次回乡，本没有什么好心绪。")
>>>print("因为我这次回乡，本没有什么好心绪。")
因为我这次回乡，本没有什么好心绪。

12.4 输入输出

#输入：
变量 = input("提示字符串")  
#输出：
print()

在print()语句中可以通过输出的语句*一个整数实现多次输出

>>>print("I am a boy!\n"*3)
I am a boy!
I am a boy!
I am a boy!

12.5 标点

编程语言中所有的标点均为英文，注释或者字符串语句中可以使用中文标点！！！

12.5.1 冒号

在控制流语句（如if、for、while等）和函数定义后需要加上冒号(😃。

12.5.2 引号

字符串可以使用单引号(‘’)或者双引号(“”)，但在同一个字符串中要保持一致。

12.6 缩进

Python使用缩进来标记代码块，缩进必须保持一致。常见的缩进约定是使用四个空格或者一个制表符作为缩进。

使用Python编程时，有几个基本的注意事项需要注意：

12.7 导入模块

使用import语句导入需要使用的模块。在导入模块时，可以使用别名来简化模块名称，例如import math as m。

12.8 数据类型

Python是动态类型语言，但是变量仍然具有数据类型。在使用变量之前，最好初始化并明确其所代表的数据类型。

12.9 避免全局变量

尽量避免使用全局变量，因为它们会增加代码的复杂性和维护难度。如果需要共享数据，可以使用函数参数或者返回值。

12.10 区分大小写

Python是区分大小写的，变量名和函数名要与调用时的大小写一致。

12.11 输出格式

当print中需要输出字符串中含有变量的值时，使用f"字符串"

当print中需要输出字符串中含有\(例如文件的地址)时,使用r"字符串"。不加上r，则会与转义字符冲突。

例如：

>>>a = 10
>>>print(f"I have {a} apples.")
I have 10 apples.
>>>print(r"D:\文件\1")
D:\文件\1

除此之外，还有.format函数可以输出含有变量的字符串

例如：

>>>print("I have  apples.".format(10))
I have 10 apples.

总结：r表达式和f表达式均是在引号前加上

r表达式	f表达式
忽略所有的转义字符	将变量的值传递

12.12 in和not in 操作符

字符串、列表和字典中的 in 和not in 操作符类似

in	not in
判断某个键或值是否在字典中	判断某个元素是否不在字典中
判断某个元素是否在列表中	判断某个元素是否不在列表中
判断某个字符或字符串是否在字符串中	判断某个字符或字符串是否不在字符串中

输出值可为布尔值，即True 和 False

12.13 代码风格

遵循Python官方推荐的PEP 8代码风格规范，使代码易于阅读和维护。

PEP 8代码风格规范：

PEP 8是Python官方推荐的代码风格规范，以下是其中的一些重要规则：

1. 缩进：使用四个空格进行缩进，不要使用制表符。

2. 行的长度：每行代码应该尽量保持在79个字符以内。在需要换行的情况下，可以使用括号、反斜杠继续符号或缩进增加进行换行。

3. 命名规则：

   • 变量名、函数名等小写字母，可以使用下划线分隔单词。
   • 类名使用驼峰命名方式，首字母大写。
   • 常量全大写，可以使用下划线分隔单词。

4. 空格：

   • 在运算符前后、逗号后、冒号后加空格。
   • 函数定义和调用的参数列表、列表、字典、元组等元素之间要加空格。
   • 空函数、类、代码块之间空一行。

5. 注释：

   • 优先使用行注释（#）而不是块注释。
   • 注释应该解释代码的意图，不要描述代码是如何工作的。
   • 在关键代码上方使用块注释给出解释。

6. 引号：

   • 字符串引号统一使用单引号或者双引号，最好保持一致。

7. 导入：

   • 每个导入独占一行。
   • 导入顺序按照标准库模块、第三方库模块、本地模块的顺序。
   • 可以使用多个导入语句，每个导入语句只导入一个模块。

8. 其他：

   • 避免不必要的空格或者空行。
   • 使用字面值而不是内建函数来比较对象是否相等（如使用x is None而不是x == None）。

PEP 8还有更多规则，以上是一些常见的规范。遵循PEP 8可以提高代码的可读性、一致性和维护性。详细的规范可以参考PEP 8文档。