Python基础总结

python的相关基本概念
1.基本类型

    整型（int）：整数，如3、2、16。
    浮点型（float）：带有小数的数字，如3.0、1.6。
    字符串：Python中用“ ’ ’ ”（单引号）或“ " " ”（双引号）括起来代表字符串，特殊字符用“\”转义。如果不希望字符被“\”转义，可以在字符串引号前加上一个“r”。例如：

1.print("c:\windows\name")   #在这里\n会被转义成换行符
2.#输出结果为
3.c:\windows
4.ame
5.print(r"c:\windows\name")
6.c:\windows\name

如果想表示多行字符串，可以用“ " " " …" " " ”三个双引号或三个单引号把字符串括起来。每行结尾会被自动加上一个换行符，如果不想输出换行符，可以在每行的最后加入“\”来避免输出换行符。

1.print("""
2.how are you?
3.I'm fine.
4.""")
5.how are you?
6.I'm fine.
7.print("""
8.how are you?\
9.I'm fine.
10.""")
11.how are you?I'm fine.

  

可以使用“+”来连接两个字符串，使用“*”来重复字符串。

    列表：可以支持存放不同类型的数据，但是通常情况下还是存放相同类型的数据。
    字面量：字符本身表面上的定义，例如数字10就是10。
    布尔类型：只有 F a l s e False False和 T r u e True True两个值。

2.运算符
算术运算符

算术运算符在数学表达式中，作用和在数学中的作用是一样的。
操作符    描述    示例
+    加法：运算符两侧的值相加    a+b
-    减法：左操作数减去右操作数    a-b
*    乘法：操作符两侧的值相乘    a*b
/    除法：左操作数除以右操作数    a/b
%    取模：左操作数除以右操作数的余数    a%b
**    幂：返回a的b次幂    a**b
//    取整除：返回商的整数部分    a//b
比较运算符

比较运算符是指对符号两边的变量进行比较的运算符。如果比较结果是正确的，返回 T r u e True True（真），否则返回 F a l s e False False（假）。
操作符    描述    示例
==    等于：比较两个对象是否相等    a==b
!=    不等于：比较两个对象是否不相等    a!=b
>    大于：返回a是否大于b    a>b
<    小于：返回a是否小于b    a<b
>=    大于等于：返回a是否大于等于b    a>=b
<=    小于等于：返回a是否小于等于b    a<=b
赋值运算符
操作符    描述    示例    展开形式
=    右边值赋给左边    a=100    a=100
+=    右边值加到左边    a+=10    a=a+10
-=    右边值减到左边    a-=10    a=a-10
*=    左边值乘以右边    a*=10    a=a*10
/=    左边值除以右边    a/=10    a=a/10
%=    左边值对右边做取模    a%=10    a=a%10
**=    左边值对右边进行幂运算    a**=10    a=a**10
//=    左边值整除右边    a//=10    a=a//10
位运算

对数字的二进制所有位数从低到高的运算。
操作符    描述    示例
&    按位与：如果相对应位都是1，则结果为1，否则为0    a&b
|    按位或：如果相对应位都是0，则结果为0，否则为1    a|b
^    按位异或：如果相对应位值相同，则结果为0，否则为1    a^b
~    按位取反：运算符翻转操作数里的每一位，即0变成1，1变成0    ~a
<<    按位左移运算符：左操作数按位左移右操作数指定的位数    a<<b
>>    按位右移运算符：左操作数按位右移右操作数指定的位数    a>>b

位运算是计算机的基础操作，但在实际应用中较少使用。
逻辑运算符

逻辑运算符广泛应用在逻辑判断上。
操作符    描述    示例
and    逻辑与：当且仅当两个操作数都为真，条件才为真    a and b
or    逻辑或：两个操作数任何一个位为真，条件则为真    a or b
not    逻辑非：用来反转操作数的逻辑状态，如果条件为 T r u e True True，则逻辑非运算符将得到 F a l s e False False    not a
关键字 i n in in和 i s is is

i n in in关键字用于判断是否包含在指定的序列中。 i s is is关键字用于判断两个标识符是不是引用同一个对象。

i s is is与==的区别： i s is is用于判断两个变量引用对象是否为同一个，==用于判断引用变量的值是否相等。
3.表达式

对于表达式的定义，我们可以简单理解为“任何有值的东西”。例如变量就是要给表达式，表达式 n u m = 123 num=123 num=123，表示的就是将123赋值给变量 n u m num num。

对于变量相同的情况，python支持连续赋值，虽然只有一行，但仍是由两个或两个以上的表达式组成。
运算符优先级

运算符不是完全遵循从左到右的顺序的。只有相同级别的运算符才遵循从左到右计算，否则优先级高的运算符优先计算。这就类似于数学计算中乘法优先于加减法。下标按优先级从高到低的顺序排列。
操作符    描述
**    指数
~ + -    按位翻转、一元加号和减号
* / % //    乘、除、取模、取整
+ -    加法、减法
>> <<    右移运算符和左移运算符
&    按位与
^ |    按位异或、按位或
<= <> >=    比较运算符
<> == !=    等于运算符
= %= /= //= -= += *= **=    赋值运算符
is    is关键字
in    in关键字
and or not    逻辑运算符
注释

相当于给代码做笔记。python中的注释必须以“#”开头。可以单独一行，也可以放在句尾。

通用序列操作

Python中有六种内置序列，其中有三种基本序列比较常见：列表、元组和字符串。

Python中的大部分序列都可以进行通用操作，包括索引、切片、相同类型序列相加、乘法、成员资格、长度、最大值和最小值。

下面以列表为例来做一些操作的说明。
索引

列表可以根据索引下标来获取元素的值，例如：

a=[1,2,3,4]
print(a[0])
结果为1
print(a[1])
结果为2

 

由上面代码可知，序列中的元素是从“0”开始从左往右编号的，元素通过编号进行访问。索引使用的语法就是：变量后面加中括号，在括号中输入所需元素的编号。

在Python中，索引不仅可以从左往右编号，还可以从右往左编号，也就是负数代表从右往左编号。需要注意的是，从右往左编号是从-1开始的。例如：

a[1,2,3,4]
print(a[-1])
#4
print(a[-2])
#3

  

切片

切片是为了获取序列中的一段元素。例如：

a=[1,2,3,4]
print(a[0:3])
#[1,2,3]

    1
    2
    3

从执行结果中我们可以看到，我们需要用一段元素两头的两个元素作为边界，并且用“ : ”隔开。这样看上去貌似是截取从下标为0的元素到下标为3的元素，但执行结果并不是这样。左边的元素包含在切片内，右边的元素不包含在元素内，就相当于是数学中的 [ a , b ) [a,b) [a,b)（左闭右开）。

同样地，切片也支持负数，也就是按从右往左的顺序的索引获取切片，例如：

a=[1,2,3,4]
print(a[-3:3])
#[2,3]

  

从右往左数，-3的位置就是2，从左往右数，3的位置就是4，于是得到 [ 2 , 4 ) [2,4) [2,4)，也就是 [ 2 , 3 ] [2,3] [2,3]了。

同时，序列的下边可以超过真实的索引长度，例如：

a=[1,2,3,4]
print(a[3:10])
#4

 

所有序列的切片都有个默认的边界值，例如：

a=[1,2,3,4]
print(a[:2]
#[1,2]
print(a[2:]
#[3,4]
print(a[:]
#[1,2,3,4]

 

由此可知，省略左边边界元素，则默认为下标0；省略右边边界元素，则默认为到序列的最后（包括最后一个元素）。

在上面的例子中，我们通过切片都是获得连续的序列，也就是1,2,3这样连续的数字，那么我们如何获得非连续的序序列呢？对于这种情况，Python的切片提供了第三个参数：步长。默认情况下步长为1。例如：

a=[1,2,3,4,5,6,7]
print(a[0:4])
#[1,2,3,4]
print(a[0:4:1])
#[1,2,3,4]
print(a[0:4:2])
#[1,3]
print(a[0:4:3])
#[1,4]

当步长为负数时（步长不能为0），Python会从序列的尾部开始向左获取元素，直到第一个元素为止。整数的步长则是从序列的头部开始从左往右获取元素。
序列相加

用“+”进行连接。例如

a=[1,2,3,4]
print(a)
#[1,2,3,4]
a=[1,2,3,4]+[5,6,7]
print(a)
#[1,2,3,4,5,6,7]
print(a+[7,8,9])
#[1,2,3,4,5,6,7,8,9]

序列和序列相加后的结果还是相同类型的序列。注意：不同类型的序列是不能相加的。
序列重复

用“*”做乘法。例如：

a=[1,2]
print(a)
#[1,2]
a=[1,2]*2
print(a)
#[1,2,1,2]
print(a*2)
#[1,2,1,2,1,2,1,2]

   

成员资格

成员资格指判断一个元素是否包含在序列中，python中使用运算符“in”来判断。“in”运算符会判读左边的元素是否包含在右边的序列中，如果包含就返回 T r u e True True（真），如果不包含就返回 F a l s e False False（假）。例如：

print(3 in [1,2,3,4])
#True
print(5 in [1,2,3,4])
#False

 

注意：只有当序列中元素的类型和值都完全一致，才算是包含在序列中，比如数字“5”和字符串“ " 5 " ”就是两种不同的元素。
长度、最小值、最大值、求和

直接看下面代码：

a=[1,2,3,4]
print(len(a))
#4
print(min(a))
#1
print(max(a))
#4
print(sum(a))
#10

  

从执行结果可以看出， l e n len len函数可以获取序列的长度， m i n min min函数可以获取序列的最小值， m a x max max函数可以获取序列的最大值。需要注意的是， s u m sum sum函数求和的要求是序列的元素必须是 i n t int int，比如 s u m sum sum函数无法对字符串序列求和。
列表
列表更新

列表可以通过索引获取其中的单个元素，也可以通过索引更新其中的元素，使用方法就和变量赋值一样。例如：

a=[1,2,3,4]
print(a[2])
#3
a[2]="hello"
print(a)
#[1,2,'hello',4]

 

由执行结果可以看出，一个列表可以存储不同类型的数据，并且修改的新元素也不需要和原来的元素类型一致。需要注意的是：更新列表的索引必须是已存在的索引，不能对超出列表长度的索引更新元素。·
增加元素

a p p e n d append append
列表不能通过索引来添加元素，索引只能修改更新现有的元素。如果要想添加新元素，可以用 a p p e n d append append方法在列表的最后追加新元素。

a=[1,2,3,4]
a.append(5)
print(a)
#[1,2,3,4,5]
a.append([6])
print(a)
#[1,2,3,4,5,[6]]
a.append([7,8])
print(a)
#[1,2,3,4,5,[6],[7,8]]

  

e x t e n d extend extend
a p p e n d append append只能增加一个元素，如果要想追加多个元素，则用 e x t e n d extend extend，例如：

a=[1,2,3,4]
a.extend([5,6])
print(a)
#[1,2,3,4,5,6]
a.extend([7])
print(a)
#[1,2,3,4,5,6,7]
a,extend(8)
print(a)
#报错

   

i n s e r t insert insert
在列表中间插入用 i n s e r t insert insert，它需要传递两个参数，第一个参数为插入的位置，第二个参数表示插入的元素，它只能插入一个元素。例如：

a=[1,2,3,4]
a.insert(2,'a')
print(a)
#[1,2,'a',3,4]
a.insert(5,5)
print(a)
#[1,2,'a',3,4,5]
a.insert(6,[6])
print(a)
#[1,2,'a',3,4,5,[6]]
a.insert(7,[7,8])
print(a)
#[1,2,'a',3,4,5,[6],[7,8]]

   

删除元素

p o p pop pop
用于移除列表中指定的一个元素，默认是最后一个元素（默认是不带参数的意思），它的参数是元素的下标，并可以返回该元素的值。例如：

a=[1,2,3,4]
a.pop()
print(a)
#[1,2,3]
a.pop(1)
print(a)
#[1,3]
b=a.pop(0)    #用b接收返回值
print(a)
#[3]
print(b)
#1

  

r e m o v e remove remove
根据元素内容来对元素进行删除，如果有多个相同的元素，只会删除查找到的第一个元素，并且没有返回值。

a=[1,2,3,4,3]
a.remove(1)
print(a)
#[2,3,4,3]
a.remove(3)
print(a)
#[2,4,3]

   

d e l del del
用于删除指定的元素。

a=['A','B','C','D']
del a[1]
print(a)
#['A','C','D']

   

查找元素

i n d e x index index
它有返回值，返回的是元素的下标。如果元素不在列表中（有返回值的可以直接打印，也可以用一个变量来接收），会报错。例如

a=['A','B','C','D']
print(a.index('C'))
#2
b=a.index('D')
print(b)
#3
print(a.index('E'))
#ValueError: 'E' is not in list

   

其它操作

r e v e r s e reverse reverse
反转列表，和“ [ : : − 1 ] [::-1] [::−1]”相似，但是 r e v e r s e reverse reverse修改的是原来的列表，没有返回值。例如：

a=['A','B','C','D']
a.reverse()
print(a)
#['D','C','B','A']

   

c o u n t count count
用于统计某个元素在列表中出现的次数。例如：

a=[1,2,3,4,1,2,3,2]
print(a.count(1))
#2
print(a.count(2))
#3
print(a.count(3))
#2

  

s o r t sort sort
用于对列表进行排序，没有返回值。

a=[1,3,2,5,4]
a.sort()
print(a)
#[1,2,3,4,5]
print(a.sort())
#None

  

元组

元组和列表十分相似，但列表可以修改、删除，元组创建之后就不能修改，不能删除单个元素，但是可以删除整个元组。

定义：元组只是边界变成了“ ( ”、“ ) ”。例如：

a=(1,2,3,4)
print(a)
#(1,2,3,4)

   删元组

d e l del del
用这个删除整个元组，例如：

a=(1,2,3,4)
del a
print(a)
#NameError: name 'a' is not defined

  

其它操作

c o u n t count count
跟列表一样
i n d e x index index
跟列表一样
字典

字典的元素由键值对组成，键和值中间有冒号。整个字典用花括号“ { } ”括起来，空字典可以直接用“ { } ”表示。字典的键必须唯一，不能重复。例如：

a={
    'A':1,
    'B':2,
    'C':3,
    'D':4
}
print(a)
#{'A':1,'B':2,'C':3,'D':4}
b={}
print(b)
#{}

 

使用字典

查找
用键去查找值。

a={
    'A':1,
    'B':2,
    'C':3,
    'D':4,
}
print(a['A'])
#1

 

注意：查找的时候用的是“ [ ] ”。
若变量名后面接了函数等，都不能用“ [ ] ”，若只是变量名才可以用“ [ ] ”。

修改 值

a = {
    'A':1,
    'B':2,
    'C':3,
    'D':4,
}
a['B'] = 5
print(a)
#{'A':1,'B':5,'C':3,'D':4}
a['E'] = 6
print(a)
#{'A':1,'B':5,'C':3,'D':4,'E',6}

   

删除 值

a = {
    'A': 1,
    'B': 2,
    'C': 3,
    'D': 4,
}
del a['A']
print(a)
#{'B':2,'C':3,'D':4}

c l e a r clear clear
清空字典的所有元素，使其变成空字典。

a = {
    'A': 1,
    'B': 2,
    'C': 3,
    'D': 4,
    }
a.clear()
print(a)
#{}

c o p y copy copy
返回一个具有相同键值对的新字典

a = {
    'A': 1,
    'B': 2,
    'C': 3,
    'D': 4,
    }
b = a.copy()
print(b)
#{'A': 1, 'B': 2, 'C': 3, 'D': 4}
del b['A']
print(b)
#{'B': 2, 'C': 3, 'D': 4}
print(a)
#{'A': 1, 'B': 2, 'C': 3, 'D': 4}

 

对从 c o p y copy copy得到的字典做修改，不会影响到原字典。

f r o m k e y s fromkeys fromkeys
用于创建一个新字典，用序列中的元素作为字典的键，第一个参数为该序列名，第二个参数为字典所有参数对应的初始值，例如：

a = ['A','B','C']
b = dict.fromkeys(a)
print(b)
#{'A': None, 'B': None, 'C': None}
c = dict.fromkeys(a,1)
print(c)
#{'A': 1, 'B': 1, 'C': 1}

 

g e t get get
用于返回键对应的值

a = {
    'A' : 1,
    'B' : 2,
    'C' : 3,
    'D' : 4,
}
print(a.get('A'))
#1

 

k e y s 、 v a l u e s keys、values keys、values
前者返回包含全部键的一个列表，后者返回包含全部值的列表

a = {
    'A' : 1,
    'B' : 2,
    'C' : 3,
    'D' : 4,
}
print(a.keys())
#dict_keys(['A', 'B', 'C', 'D'])
print(a.values())
#dict_values([1, 2, 3, 4])

 

i t e m s items items
用于返回一个包含所有键值对的类似于 l i s t list list的一个结构。

a = {
    'A' : 1,
    'B' : 2,
    'C' : 3,
    'D' : 4,
}
print(a.items())
#dict_items([('A', 1), ('B', 2), ('C', 3), ('D', 4)])

集合

它与列表类似，唯一的区别就是它不含重复值，且用花括号“ { } ”括起来。
可用 s e t ( ) set() set()函数来定义集合。

a = set((1,2,3))
print(a)
#{1,2,3}
b = set([1,2,3])
print(b)
#{1,2,3}
c = set()
print(c)
#set()
d = {1,2,3}
print(d)
#{1,2,3}

 

s e t ( ) set() set()的括号里可以是其它的数据结构，但输出出来的都是花括号，也可以直接用括号定义。但空集合必须要用 s e t ( ) set() set()。

 i f if if判断

语句格式如下：

if 表达式:
    语句1
    语句2

   

注意❗️：“语句1”、“语句2”前有一个缩进（相当于4个空格）不能省略。 i f if if判断语句是根据它旁边表达式的真假来决定要不要执行下面的语句。也就是 i f if if右边表达式的值只有 T r u e True True或 F a l s e False False两种。

a = 1
b = 2
c = 0
if a < b:
    print("you are right!")
#you are right!
if a > b:
    print("you are wrong!")
#
if a:
    print("yes");
#yes
if c:
    print("no");
#

  

对于上面的代码，由于 a < b a < b a<b是正确的，所以它的值是 T r u e True True，执行该 i f if if判断下面的语句。而 a > b a > b a>b是错误的，所以它的值是 F a l s e False False，不会执行该 i f if if判断下面的语句。

此外还要说明一种情况👉：当表达式是一个空的数据结构时，它也是 F a l s e False False值，例如👇：

a = [ ]
b = ( )
c = { }
if a:
    print("yes")
#
if b:
    print("yes")
#
if c:
    print("yes")
#

❗️：上面的空列表、空元组和空字典都被判断为 F a l s e False False，但是只要这些数据结构中有一个元素，就会被判断为 T r u e True True。
e l s e else else语句

e l s e else else跟在 i f if if后，只要 i f if if的表达式判断为 F a l s e False False，就执行后面的 e l s e else else语句。❗️❗️❗️： e l s e else else不能单独出现，只能跟在 i f if if后。例如👇：

a = 1
b = 2
if a > b:
    print("a > b")
#
else:
    print("a < b")
#a < b

  

e l i f elif elif语句

单独一个 e l s e else else有时候也许不能满足要求，这时就可以用 e l i f elif elif， e l i f elif elif可以有多个。 e l i f elif elif和 e l s e else else都是 i f if if的可选项。且 e l i f elif elif也不能单独出现，只能跟在 i f if if后面，当既有 e l i f elif elif也有 e l s e else else时， e l s e else else要只能在最后，不能插到 e l i f elif elif前面去。例如👇：

a = 1
b = 2
if a > b:
    print("a > b")
#
elif a < b:
    print("a < b")
#a < b
else:
    print("a == b")
#

  

2. 循环
w h i l e while while循环

它的语法格式👇：

while 表达式:
    语句1
    语句2

 

它的意思就是只要表达式的值为 T r u e True True，就循环执行 w h i l e while while里面的语句。直到表达式的值为 F a l s e False False就退出循环。

a = 1;
while a <= 5:
    print(a)
    a += 1
#1
#2
#3
#4
#5

 

❗️：在使用循环的过程中，要避免死循环。什么是死循环❓死循环就是 w h i l e while while旁边的表达式一直为 T u r e Ture Ture，不会停止。
例如👇：

a = 1;
while a > 0:
    print(a)
    a += 1

  

上面的循环就是一个死循环，因为循环内 a a a一直在加1，而它本身又是大于0的，所以循环就结束不了，最终可能导致系统资源被耗尽。
f o r for for循环

语法👇：

for 变量 in 序列:
    语句

    1
    2

f o r for for循环跟 w h i l e while while循环有点不一样， w h i l e while while循环是判断通过表达式的是值否为 T r u e True True来选择是否执行其内的语句。而 f o r for for循环则是用 x x x去遍历序列中所有元素，遍历完后就结束循环，也就是说 f o r for for循环是规定了循环次数的。

for x in {1,2,3}:
    print(x + 1)
#2
#3
#4

 

也可以用 r a n g e range range函数来表示循环的次数。

for x in range(3):
    print(x)
#0
#1
#2
for x in range(3):
    print(1)
#1
#1
#1

  

r a n g e range range函数若只有一个参数，参数为元素的个数，默认从0开始。💨同时也可以有两个或三个参数。两个参数的情况就是一个开始位置到结束位置，但不包括结束位置。还有一个就是增长步进，默认为1。
b r e a k break break

其作用是立即退出循环体，直接结束循环，例如👇：

for x in range(4):
    if x == 2:
        break
    print(x)
#0
#1

  

c o n t i n u e continue continue

其作用是跳过当前循环而执行下一次循环，例如👇：

for x in range(1,6):
    if x == 3:
        continue
    print(x)
#1
#2
#4
#5

 

3. 其它
p a s s pass pass

在python中， p a s s pass pass是一个空语句，其作用是保持程序结构的完整性。 p a s s pass pass不做任何操作，一般用做占位语句，例如👇：

for x in range (1,4):
    if x > 2:
        pass
    print(x)
#1
#2
#3

   

可以看出来 p a s s pass pass语句没有任何影响。
循环语句中的 e l s e else else

e l s e else else与 w h i l e while while
当 w h i l e while while的条件表达式的值为 F a l s e False False时就会去执行 e l s e else else，例如👇：

x = 0
while x <= 2:
    print(x)
    x += 1
else:
    print("end")
#0
#1
#2
#end

 

❗️：如果循环中有 b r e a k break break则不会执行 e l s e else else，下同。

e l s e else else与 f o r for for

for x in range(3):
    print(x)
else:
    print(x)
#0
#1
#2
#2