python 入门知识点
我们在入门python的时候，经常知道思路，但是却找不到合适的方法来处理。这里小编搜集了好几本python入门教程，尽可能将里面的一些基础性的知识点整理了出来，特在此将此分享给大家，供大家查阅。
python的解释器
这里小编就不多赘述了，可以去网上搜索相关教程。建议下载最新版的anaconda和pycharm。
六种数据类型及之间的相互转换
六种数据类型
| 数据类型 | 名称 |
|---|---|
| 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'>
相互转换：
| 函数 | 描述 |
|---|---|
| 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)元组序列 |
数的相关知识
运算符
运算符分为算术运算符，赋值运算符和比较运算符
其中的优先级为：
1.**
2.算术运算符： * / % // + -
3.比较运算符：<= < > >= == !=
4.赋值运算符：= %= /= //= -= += *= **=
算术运算符 > 比较运算符 > 赋值运算符
算术运算符
| 运算符 | 意义 | 例子 |
|---|---|---|
| + | 两个数相加 | 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
比较运算符
| 运算符 | 意义 | 例子 |
|---|---|---|
| = | 常规赋值运算符 | 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=a**b) |
赋值运算符
| 运算符 | 意义 | 例子 |
|---|---|---|
| == | 比较两个对象是否相等 | a==b |
| != | 比较两个对象是否不相等 | a!=b |
| > | 大于（大小比较） | aq>b |
| < | 小于（大小比较） | a |
| >= | 大于等于（大小比较） | a>=b |
| <= | 小于等于（大小比较） | a<=b |
逻辑运算符
| 运算符 | 意义 | 例子 |
|---|---|---|
| and | “与”运算符，一假为假，全真为真 | a and b |
| or | “或”运算符，一真为真，全假为假 | a or b |
| not | “非”运算符，为真则假，为假则真 | not a not(a and b) |
数中的下划线
书写很大的数时，也可以使用下划线将其中的数字分组，使其更清楚易读
>>> a = 100_000_000_000
>>> print(a)
100000000000
常量
常量类似于变量，其值在整个生命周期内不变，一般用全部大写字母表示某个量是常量。
MAX_RMB_PAR_VALUE = 100
注释
井号字符（#）只能单行注释
多行字符串（三重引号）可以多行注释
输入输出
输入：变量 = input(‘提示字符串’)
输出：print()
在print()语句中可以通过输出的语句*一个整数实现多次输出
>>>print("I am a boy!\n"*3)
I am a boy!
I am a boy!
I am a boy!
判断语句
1.if 判断条件 :
[][]语句……
2.if 判断条件：
[][]语句……
else：
[][]语句……
3.if 判断条件：
[][]语句……
elif 判断条件：
[][]语句……
n个……
else：
[][]语句……
注意： [][]表示缩进，空4个字节
例如：定义一个整数变量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("该人不存在！！")
循环语句
循环语句主要分为while语句和for语句
while 语句
while语句由三部分组成：
1.while
2.条件表达式和冒号
3.当条件表达式结果为真时要执行的循环体
while 表达式 ：
[][]循环体
for循环
for 循环变量 in 遍历对象(序列)：
[][]循环体
for 循环，从形式上可以分为俩种：
1.遍历对象
2.使用range函数控制循环次数
range函数:
range(起始值，终止值，步长)
步长 ：每次循环序列增长值
例如：输出1-100内所有的奇数和偶数
使用while循环
i = 0
while i <= 100:
if i % 2 == 0:
print(f"偶数：{i}")
if i % 2 == 1:
print(f"奇数：{i}")
i += 1
使用for循环
for i in range(1,101,1):
if i % 2 == 0:
print(f"偶数：{i}")
if i % 2 == 1:
print(f"奇数：{i}")
字符串
转义字符
| 转义字符 | 输出为 |
|---|---|
| \’ | ’ |
| \" | " |
| \t | 制表符 |
| \n | 换行符 |
| \\ | 倒斜杠 |
原始字符串
可以在字符串开始的引号之前加上r，使他成为原始字符串。原始字符串完全忽略所有的转义字符，可以输出字符串中所有的倒斜杠。
>>>print(r'This is a \'boy')
This is a \'boy
相似：还有一种与r表达式相似的表达式叫f表达式
f表达式的作用：格式化字符串可以写为f’{表达式}’。在字符串前面加入一个f表达式，字符串{变量名}引用变量。
f表达式的输出格式：(x为要输出的内容)
print(f’XXXX{真实值1}XXXXXX{真实值2}XXXX’)
>>>a = 18
>>>b = 20
>>>print(f'小明今年{a}岁了，他的姐姐小红今年{b}岁了。')
小明今年18岁了，他的姐姐小红今年20岁了。
总结：r表达式和f表达式均是在引号前加上
| r表达式 | f表达式 |
|---|---|
| 忽略所有的转义字符 | 将变量的值传递 |
注释
井号字符（#）只能单行注释
多行字符串（三重引号）可以多行注释
'''
我所记得的故乡全不如此。我的故乡好得多了。
但要我记起他的美丽，说出他的佳处来，却又没有影像，没有言辞了。
仿佛也就如此。于是我自己解释说：故乡本也如此，
——虽然没有进步，也未必有如我所感的悲凉，这只是我自己心情的改变罢了，
因为我这次回乡，本没有什么好心绪。
'''
#print("因为我这次回乡，本没有什么好心绪。")
>>>print("因为我这次回乡，本没有什么好心绪。")
因为我这次回乡，本没有什么好心绪。
字符串的索引、切片与逆序
"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结束，按照左闭右开，需要再往右延伸一个，即减一。
字符串的in和not in 操作符
| in | not in |
|---|---|
| 判断某个字符或字符串是否在字符串中 | 判断某个字符或字符串是否不在字符串中 |
输出值可为布尔值，即True 和 False
字符串的连接
使用"+"连接
>>>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是整型不能与字符串同时输出。
字符串方法
| 方法 | 使用方法 | 作用 |
|---|---|---|
| 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
使用ord()和chr()函数的字符的数值
ord(字符)获取一个单字符字符串的代码点
chr(代码点)获取一个整数代码点的单字符字符串
列表
创建一个空列表：
a = [ ]
访问列表中的某个元素，可以使用
a[索引]
如果要访问列表的最后一个元素，可以使用
a[-1]
看到这里是不是发觉与字符串的索引很像，的确他们的形式是一样的。
以此类推，列表的切片和逆序与字符串格式一致，也是a[ : : ]和a[ : :-1],同时别忘记逆序时开始索引与结束索引的位置。
列表方法
增
列表.append(元素) : 在列表末尾添加一个元素
列表.extend(序列): 在列表末尾追加一个序列
列表.insert(索引，元素): 在列表对应的索引插入元素
删
del 列表[索引]：删除列表中对应索引的元素。
列表.pop(索引): 删除列表中对应索引的元素，并返回删除的元素，默认最后一个。
列表.remove(元素): 删除列表中对应元素的第一个匹配项。
列表.clear():清空列表
改
列表[索引]=新元素：将列表对应索引的元素，修改为新元素。
查
列表.index(元素): 返回元素对应的索引
排序
1.sort()：可以对列表进行永久排序
列表.sort(reverse=True/False)
2. sorted()可以对列表进行临时排序
sorted(列表名,reverse=True/False)
reverse=True 时，按降序排序。
reverse=False 时，按升序排序。
列表推导式
[表达式 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]
列表操作
len()函数
len()函数可以取得列表的长度
>>>a = [11,22,33,44,55]
>>>print(len(a))
5
连接与复制
像字符串一样，+操作符可以连接两个列表，得到一个新的列表；*操作符可以用于一个列表和一个整数，实现列表的复制
>>>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]
sum()函数
sum()函数可以将列表中所有数相加
>>>a = [11,22,33]
>>>print(sum(a))
66
in 和not in 操作符
列表的in 和 not in 操作符与字符串的用法类似
| in | not in |
|---|---|
| 判断某个元素是否在列表中 | 判断某个元素是否不在列表中 |
| 判断某个字符或字符串是否在字符串中 | 判断某个字符或字符串是否不在字符串中 |
输出值可为布尔值，即True 和 False
enumerate()函数
在for循环中迭代，每次enumerate()函数将返回两个值：列表表项的索引和列表表项本身。
random.choice()和random.shuffle()函数
random.choice()函数将从列表中返回一个随机选择的表项。
random.shuffle()函数将对列表中的表项重新排序。该函数将就地修改列表，而不是返回新列表。
多重赋值
使用多重赋值是一种快捷方式，在一行代码中，用列表中的值为多个变量赋值。
所以，不用输入以下代码
>>>cat = ['fat','black','loud']
>>>size = cat[0]
>>>color = cat[1]
>>>disposition = cat[2]
而是通过以下代码实现
>>>cat = ['fat','black','loud']
>>>size,color,disposition = cat
元组
创建一个空元组：
a =（）
创建包含一个元素的元组：
b =（元素,）
创建元组：c =（元素1,元素2,……）
元组的访问
获取一个元素：
元组序列[所有]
获取多个连接的元素：
元组序列[开始索引,结束索引]
注意：元组是不可以修改的，包括不能删除其中的元素。元组内的直接数据如果修改则立即报错。但是，如果元组里面有列表，修改列表里面的数据不会报错。
元组的操作
| 操作 | 作用 |
|---|---|
| index() | 从元组中找出某个对象第一个匹配项的下标位置。 |
| count() | 统计某个元素在元组中出现的次数。 |
| len() | 计数元组元素的个数，并返回值。 |
| max() | 返回元组中元素的最大值。 |
| min() | 返回元组中元素的最小值。 |
注意：元组除了两个方面，元组的数据类型几乎和列表数据类型一样：
1.元组输入时用圆括号(),不是方括号[ ]
2.元组的值无法修改、添加或删除。
字典
创建空字典：
dict1 = {}
dict2 = dict()
创建字典：
dict3 = { 键1 :值1 ,键2: 值2,……}
如：dict3 = {‘name’: ‘小编’, ‘age’: 18}
特点
1.符号为大括号{}
2.数据为键值对形式出现
3.各个键值对之间用逗号隔开
字典的操作
访问值：
字典序列[键]
修改值:
字典序列[键]=新值
添加键值对:
字典序列[新键]=新值
删
删除字典中对应的键的键值对：
del 字典序列[键]
删除字典：
del 字典序列
清空字典：
字典序列.clear()
查
查找字典的所有的键值对：
字典序列.items()
查找字典的所有的key(键)：
字典序列.keys()
查找字典的所有的value(值)：
字典序列.values()
使用enumerate()函数枚举键值对
enumerate(序列, start=0)
其中start = 0为默认开始值为0
in 和not in 操作符
字典中的 in 和not in 操作符与列表和字符串中类似
| in | not in |
|---|---|
| 判断某个键或值是否在字典中 | 判断某个元素是否不在字典中 |
| 判断某个元素是否在列表中 | 判断某个元素是否不在列表中 |
| 判断某个字符或字符串是否在字符串中 | 判断某个字符或字符串是否不在字符串中 |
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.
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.集合可以用来去重
集合操作
增
添加一个数据：
集合序列.add(数据)
添加序列：
集合序列.update(序列数据)
删
集合序列.remove(数据)
删除集合中指定的数据，如果数据不存在就报错
集合序列.pop()
随机删除集合中的某个数据
集合序列.discard(数据)
删除集合中指定的数据，如果数据不存在不做任何操作
函数
如果在开发程序时，需要某块代码多次，为了提高编写的效率以及代码的重用，就把具有独立功能的代码块组织为一个小模块，这一个小模块就是函数。
作用:
1.减少代码的重复性。
2.使代码可读性更好。
定义函数语法：
def 函数名 ( ):
[][]函数语句
调用函数语法：
函数名( )
注意：1.函数先定义后调用，如果先调用会报错。
2.函数没有被调用时，函数里面的执行语句不会被执行。
返回值
函数并非总是直接显示输出，有时也可以处理一些数据，再返回处理好的数据。函数返回的数据称为返回值。
语法：
def 函数名 ( ):
[][]函数语句
[][]return 返回值
注意：函数中可以同时包含多个 return 语句，但只会执行了一个return,return的功能是返回值并退出当前函数，return语句后面的语句都不执行。
形参和实参
定义格式:
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.
参数
参数分为三种：
1.位置参数(必备参数)
2.默认参数(缺省参数)
3. 不定长参数(*args,**kwargs)
*args常以元组的形式输出，收集任意数量的位置实参
**kwargs常以字典的形式输出，收集任意数量的关键字实参
位置参数
def 函数名(形参1,形参2):
[][]函数体
函数名(实参1，实参2)
默认参数
def 函数名(形参1=数据,…):
[][]函数体
不定长参数
不定长参数(*args)
def 函数名(*args):
[][]函数体
函数名(实参1，实参2，实参3,……)
不定长参数(**kwargs)
def 函数名(**kwargs):
[][]函数体
参数定义顺序：
位置参数、默认参数、不定长参数(*args,**kwargs)
作用域
变量作用域就是指变量的作用范围，在什么范围内起作用。
变量作用域主要分为局部作用域和全局作用域。
局部作用域
定义在函数内部的变量拥有一个局部作用域，表示只能在声明它的函数内部访问。在函数体内部，临时保存数据，即当函数调用完成后，则销毁局部变量。
全局作用域
定义在函数外部的变量拥有全局作用域，表示可以在整个程序范围内访问（函数内、外部都能生效）。
修改作用域
| 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
最后
如果你觉得这篇文章对你有用，建议点赞收藏。
欢迎各位读者指正错误，请在评论区留言。或者发表自己的看法，小编不胜感激。