python语言介绍
Python是一种计算机程序设计语言，是一种面向对象的动态类型语言，一种解释型脚本语言，也被称为是“胶水语言”，python代码简洁、易读性、可扩展性、可维护性和可移植性强，是一种用途广泛的语言，涉及众多领域，图像处理、web编程、数据分析、爬虫、多媒体应用、大数据、人工智能……等等众多领域，非常适合初级编程学习。
下面就以常用的python基础做一简单总结，如有写的不对的地方，希望大家能够指出来，我们共同进步！
一、运算符
- 算术运算符： ‘+’ 加、 ‘-’ 减、 ‘*’ 乘 、 ‘/’ 除以 、 ‘%’ 取余 、 ‘**’ 指数幂 、 ‘//’ 整除
- 赋值运算符：
a
=
2
# = 将2赋值给a
a
+=
2
# += 加法赋值运算符-> a = a + 2
a
-=
2
# -= 减法赋值运算符-> a = a - 2
a
*=
2
# *= 乘法赋值运算符-> a = a * 2
a
/=
2
# /= 除法赋值运算符-> a = a / 2
a
%=
2
# %= 取模赋值运算符-> a = a % 2
a
**=
2
# **= 幂赋值运算符-> a = a ** 2
a
//=
2
# //= 整除赋值运算符-> a = a // 2
- 逻辑运算符
# and 逻辑与 a and b 两者同真才为真 True 否则都为假 False
# or 逻辑或 a or b 两者同假才为假 False 否则都为真 True
# not 非运算 not a 若a为假，则为True 否则为False
- 成员运算符
# in 是否在指定的序列中 x in y 若x在y中，则为True，否则为False
# not in 是否不在指定的序列中
- 身份运算符
# is 判断对象内存地址 print(id(a) is id(b)) 如果内存地址相同则为True，否则为False
# is not 判断不是 print(a is not b) 正确为True，否则为False
二、 基本数据类型
-
数字型（Number）：包括整型和浮点型
1.整型 （int）： 即整数10
2.浮点型（float）：即小数 2.5 - 空值 （None）：即0、[]、{}、’’
- 布尔型（bool）：（True，False）对应->（1,0）
- 字符串 （str）： “abcde”，‘defs’, “”“gfakgfka”"",单引号，双引号，三引号都可以表示字符串，三引号也可作注释
- 列表（list）：[1,2,3]，用[]表示
- 元组（tuple）：（1,2,3）用（）表示
- 字典（dict）：{‘name’:‘Tom’} 用{}表示，以键值对的形式name为键名key，Tom为值value
- 集合（set）：{1,2,3} 用{}表示，以逗号隔开
- 复数（complex）：即虚数，1 + 2j，表示方法和数学上差不多，较少用到
- 二进制数据类型（bytes） ：b’dfGFkggkasfg’，字符串前加b,表示bytes类型数据。
三、序列类型常用方法
1.列表（list）
列表是一种有序的集合【有序：数据的存放顺序和内存中的存储顺序是相同的，列表中的数据在内存中的地址是连续的,列表是一种可变的序列】
-
增
append()：在列表的末尾添加新元素，添加单个元素,写多个直接报错
list1 = [ 'Tom' , 'Harry' , 'Lili' ] list1 . append ( 'Jery' ) print ( list1 ) # ['Tom','Harry','Lili','Jery'] # 添加列表，会当成一个元素添加到列表尾部 list1 . append ( [ 1 , 2 , 3 ] ) print ( list1 ) # ['Tom', 'Harry', 'Lili', 'Jery', [1, 2, 3]]insert(): 插入，指定位置( 索引下标)插入元素
#如果下标超过索引的范围，如果是正数，则默认插入到列表末尾；如果是负数，则默认插入到列表开头 list1 = [ 'Tom' , 'Harry' , 'Lili' ] list1 . insert ( 1 , 'xiaomi' ) print ( list1 ) # ['Tom','xiaomi','Harry','Lili'] list1 . insert ( - 10 , 'haha' ) print ( list1 ) # ['haha','Tom','xiaomi',Harry','Lili']拼接列表
list1 = [ 1 , 2 , 3 ] list2 = [ 4 , 5 , 6 ] # 拼接列表的方法还有很多，下面简单介绍几种 """ extend():拼接扩展列表,在前一个列表的末尾拼接另一个列表， 前一个列表增加元素，后一个列表不变,还可以拼接其他可迭代对象,打碎添加进去 """ list1 . extend ( list2 ) print ( list1 ) # [1,2,3,4,5,6] list1 . extend ( "fgajfg" ) print ( list1 ) # [1, 2, 3, 4, 5, 6, 'f', 'g', 'a', 'j', 'f', 'g'] # "+" 拼接，生成新的列表 li = list1 + list2 print ( li ) # [1,2,3,4,5,6] # 选择位置拼接： a = [ 1 , 2 , 3 ] a [ : 0 ] = [ 0 ] # 在首部拼接 [0, 1, 2, 3] a [ - 1 : ] = [ 4 , 5 , 6 ] # 在尾部拼接 [0, 1, 2, 3, 4, 5, 6] a [ 3 : 3 ] = [ "a" , "b" ] # 在中部拼接 [0, 1, 2, 'a', 'b', 4, 5, 6] # 列表替换方法： li = [ 1 , 2 , 3 , 4 ] li [ : 1 ] = "a" # 替换一个 ['a', 2, 3, 4] li [ : 3 ] = [ 7 , 8 , 9 ] # 替换三个 [7, 8, 9, 4] li [ 1 : 3 ] = [ "b" , "c" , "d" , "e" ] # 非等长替换 [7, 'b', 'c', 'd', 'e', 4] # 带步长的替换一定要长度对等，即要替换的长度和替换的序列的长度要想等，否则报错 li [ : : 2 ] = [ 1 , 2 , 3 ] # 带步长替换 [1, 'b', 2, 'd', 3, 4] li [ : : 2 ] = [ 1 , 2 , 3 , 4 ] print ( li ) # ValueError: attempt to assign sequence of size 4 to extended slice of size 3 -
删
pop():删除，指定位置删除，索引下表
list1 = [ 1 , 2 , 3 , 4 ] list1 . pop ( 2 ) print ( list1 ) # [1,2,4] # 不写默认删除最后一个 list1 . pop ( ) print ( list1 ) # [1,2]del删除
# 删除元素： list1 = [ 1 , 2 , 3 , 4 , 5 ] del list1 [ 1 : 3 ] # 指定长度删除元素 print ( list1 ) # [1, 4, 5] list2 = [ 1 , 4 , 5 , 6 , 7 , 8 , 9 ] del list1 [ : : 2 ] # 带步长删除 print ( list2 ) # [4, 6, 8]remove：指定元素删除
list1 = [ 1 , 2 , 3 , 4 ] list1 . remove ( '2' ) print ( list1 ) # [1,3,4] # 若有相同元素，则删除第一个clear：清空整个列表
list1 = [ 1 , 2 , 3 ] list1 . clear ( ) print ( list1 ) # [] -
改
指定位置修改
list1 = [ 'Tom' , 'Harry' , 'Lili' ] list1 [ 1 ] = 'xiaomi' print ( list1 ) # ['Tom','xiaomi','Lili'] -
查
index索引查，查询下标
list1 = [ 'Tom' , 'Harry' , 'Lili' ] print ( list1 . index ( 'Lili' ) ) # 2 # 若有多个相同的元素，则返回第一个元素的下标，若该元素不在列表中，则报错通过索引获取值
list1 = [ 1 , 2 , 3 , 4 ] print ( list1 [ 1 ] ) # 2count 查找某元素在序列中的个数
list1 = [ 1 , 2 , 3 , 4 , 1 , 2 , 1 ] print ( list1 . count ( 1 ) ) # 3 -
其他方法
copy 列表里的拷贝
#一维列表 list1 = [ 11 , 22 , 33 ] list2 = list1 . copy ( ) print ( list1 ) # [11, 22, 33] print ( list2 ) # [11, 22, 33] print ( id ( list1 ) == id ( list2 ) ) # False print ( id ( list1 ) , id ( list2 ) ) # 2025481596616 2025481596872 list1 [ 2 ] = 100 print ( list1 ) # [11, 22, 100] print ( list2 ) # [11, 22, 33] print ( id ( list1 ) == id ( list2 ) ) # False print ( id ( list1 ) , id ( list2 ) ) # 2025481596616 2025481596872 #二维列表 list1 = [ [ 11 , 22 , 33 ] , [ 44 , 55 ] ] list2 = list1 . copy ( ) print ( list1 ) # [[11, 22, 33], [44, 55]] print ( list2 ) # [[11, 22, 33], [44, 55]] print ( id ( list1 ) == id ( list2 ) ) # False print ( id ( list1 ) , id ( list2 ) ) # 2025481609288 2025481596616 list1 [ 1 ] [ 1 ] = 100 print ( list1 ) # [[11, 22, 33], [44, 100]] print ( list2 ) # [[11, 22, 33], [44, 100]] print ( id ( list1 ) == id ( list2 ) ) # False print ( id ( list1 ) , id ( list2 ) ) # 2025481609288 2025481596616 """ 列表中的copy 一维列表：一个列表发生改变，另外一个列表不会随着发生改变 二维列表：当修改二维列表中的元素，当一个列表发生改变，另外一个列表也会随着发生改变 """ # 深浅拷贝 # 浅拷贝 import copy list1 = [ 11 , 22 , 33 ] list2 = copy . copy ( list1 ) print ( list1 ) # [11, 22, 33] print ( list2 ) # [11, 22, 33] print ( id ( list1 ) == id ( list2 ) ) # False list1 [ 2 ] = 100 print ( list1 ) # [11, 22, 100] print ( list2 ) # [11, 22, 100] print ( id ( list1 ) == id ( list2 ) ) # False # 二维列表 a = [ 1 , 2 , 3 ] b = [ 4 , 5 , 6 ] c = [ a , b ] d = copy . copy ( c ) print ( c ) # [[1, 2, 3], [4, 5, 6]] print ( d ) # [[1, 2, 3], [4, 5, 6]] print ( id ( c ) == id ( d ) # False a . append ( 100 ) print ( c ) # [[1, 2, 3, 100], [4, 5, 6]] print ( d ) # [[1, 2, 3, 100], [4, 5, 6]] # 深拷贝：copy.deepcopy() # 一维列表 list1 = [ 11 , 22 , 33 ] list2 = copy . deepcopy ( list1 ) print ( list1 ) # [11, 22, 33] print ( list2 ) # [11, 22, 33] print ( id ( list1 ) == id ( list2 ) ) # False list1 [ 2 ] = 100 print ( list1 ) # [11, 22, 100] print ( list2 ) # [11, 22, 33] print ( id ( list1 ) == id ( list2 ) ) # False # 二维列表 a = [ 1 , 2 , 3 ] b = [ 4 , 5 , 6 ] c = [ a , b ] d = copy . deepcopy ( c ) print ( c ) # [[1, 2, 3], [4, 5, 6]] print ( d ) # [[1, 2, 3], [4, 5, 6]] a . append ( 100 ) print ( c ) # [[1, 2, 3, 100], [4, 5, 6]] print ( d ) # [[1, 2, 3], [4, 5, 6]] """ 1.对于一维列表，copy和deepcopy之后的结果，一个列表发生改变，另外一个列表不受影响 2.对于二维列表 a.copy:只拷贝最外层，当一个列表的二维列表中的元素发生改变，则另外一个列表也会随着发生改变 b.deepcopy:拷贝里外层，当一个列表的二维列表中的元素发生改变，另外一个列表不受影响 """reverse 反转列表
list1 = [ 1 , 5 , 3 , 4 ] list1 . reverse ( ) print ( list1 ) # out [4,3,5,1]max/min求最值
list1 = [ 1 , 23 , 45 , 613 , 46 , 13 , 45 ] print ( max ( list1 ) ) # 613 print ( min ( list1 ) ) # 1len求长度/sum求和
list1 = [ 1 , 2 , 3 , 4 , 5 , 6 , 7 , 8 ] print ( len ( list1 ) ) # 8 print ( sum ( list1 ) ) # 36交换两个变量的值
# python中特有的语法 a = 10 b = 20 a , b = b , a print ( a , b ) # 20 10sort 排序
list1 = [ 51 , 12 , 55 , 21 ] list1 . sort ( ) print ( list1 ) # out [12,21,51,55] # 倒序，reverse=True为倒序，False为正序 list1 . sort ( resverse = True ) print ( list1 ) # out [55,51,21,12] # sort 函数中，有个关键字key，可以自定义排序的规则 list2 = [ 'ssfafa' , 'sad' , 'asfafaf' , 'asffa' ] list2 . sort ( key = len , reverse = True ) print ( list1 ) # out ['asfafaf', 'ssfafa', 'asffa', 'sad']切片 ：访问序列的方式
# [a:b:c] a,b,c为元素下标，[start,end,step] start:起始位置，end：结束位置（取不到），step 步长 list1 = [ 0 , 1 , 2 , 3 , 4 , 5 , 6 , 7 , 8 , 9 ] print ( list1 [ : ] ) # 获取全部 [0,1,2,3,4,5,6,7,8,9] print ( list1 [ 0 : ] ) # 获取全部 [0,1,2,3,4,5,6,7,8,9] print ( list1 [ : 5 ] ) # [0,1,2,3,4] print ( list1 [ 1 : 7 : 2 ] ) # [1, 3, 5] print ( list1 [ - 1 ] ) # 9 print ( list1 [ - 1 : - 5 ] ) # [] print ( list1 [ 5 : 1 : - 1 ] ) # [5, 4, 3, 2] """ 因为步长为正，则正着取，即取【-1+步长】的这一位，即0位的元素， 不在索引范围内，故取不到值，即（start，end都为负数，start>end， step为正时，返回[]，也就是说，start，end都是负数时，正着取，start一定要小于end， 否则为空，同样，start,end都是整数， 倒着取，start一定要大于end） """ print ( list1 [ - 5 : - 1 ] ) # [5, 6, 7, 8] end取不到 print ( list1 [ - 1 : - 7 : - 2 ] ) # 倒着取 [9, 7, 5] print ( list1 [ - 5 : - 1 : - 1 ] ) # [] 同理，[start + step] 不在范围内，故为[] # 不管顺着取，还是倒着取，[start + step]不在区间内就返回[],记住这一点就差不多了。 # 特殊情况 print ( list1 [ 0 : - 1 ] ) # [0,1,2,3,4,5,6,7,8] -1位为列表最后一位元素，故start >0 ,end < 0 ,为顺着开头，倒着结尾的这个区间，一旦交叉，返回[] # 但加了步长又会不一样 print ( list1 [ 0 : - 1 : - 1 ] ) # [],加了步长就要用上面的那种办法考虑了 # 切片还有很多有意思的地方，这里就简单说这么多了。
2.元组(tuple)
元组：和列表类似，元组也是一个有序的集合，元组和列表的不同之处： 定义，列表：[],元组：(),列表是一种可变的数据类型【可以增加或者删除或者更改元素】，元组是一种不可变的数据类型【一旦定义好一个元组，该元组内部的元素将不能再发生任何的改变】
-
表示
tuple1 = ( 1 , 2 , 3 ) # 定义的元组里面要在里面加","号，否则系统会默认为是其他的类型 -
获取元素
# 元组获取元素的方式和列表相同 tuple1 = ( 1 , 2 , 3 , 4 , 5 ) print ( tuple1 [ 1 ] ) # 2 # 元组是不可变类型，但如果元组中的元素是列表的话，就可以随意修改了 tuple2 = ( [ 1 , 2 , 3 ] , [ 4 , 5 , 6 ] ) tuple2 [ 1 ] . append ( "a" ) print ( tuple2 ) # ([1, 2, 3], [4, 5, 6, 'a']) -
组合
t1 = ( 1 , 2 , 3 ) t2 = ( 4 , 5 , 6 ) print ( t1 + t2 ) # (1, 2, 3, 4, 5, 6) # 但可以相加，组合成一个新的元组 print ( t1 ) # (1, 2, 3) # 不可变类型 -
重复元素
t1 = ( 1 , 2 ) print ( t1 * 3 ) # (1,2,1,2,1,2) # 因为是不可变类型，故只要是修改的方法，都是生成一个新的数据 -
其他方法
tuple1 = ( 1 , 2 , 3 , 4 ) = # len()求长度 print ( len ( tuple1 ) ) # 4 # sum() 求和 print ( sum ( tuple1 ) ) # 10 # max()/min()最大值/最小值 print ( max ( tuple1 ) ) # 4 print ( min ( tuple1 ) ) # 1 # count() 查看元素个数 print ( tuple1 . count ( 2 ) ) # 1 # index() 查看元素下标 print ( tuple1 . index ( 1 ) ) # 0 # del 删除元组 del tuple1 print ( tuple1 ) # 报错，未定义 # 元组可以和列表互相转化 l1 = list ( tuple1 ) print ( l1 ) # [1, 2, 3, 4] print ( tuple ( l1 ) ) # (1,2,3,4) # 因为元组是不可变类型，故它的方法较少
3.字符串（str）
字符串：用单引号，双引号，三引号包裹起来一些元素，这种数据就叫做字符串，其中若有一些特殊字符，则需要用“\”来转义
-
表示
a = '这是字符串！' # 单引号 b = "这也是字符串！" # 双引号 # 单引号和双引号不借助换行符不能直接换行表示，三引号可以直接换行表示 c = '''这还是字符串！''' # 三引号，也做注释 -
索引 切片方法都一致
str1 = '今天天气不错！' print ( str1 [ 3 ] ) # 气 print ( str1 [ 0 : 3 ] ) # 今天天 -
查/判断
count 查询某元素在该序列中出现的次数str1 = 'hello,world!' print ( str1 . count ( 'o' ) ) # 2index /find 查询某元素在该序列中的位置（下标）区别：index查找不存在的值会报错，而find会返回-1
str1 = 'hello world!' print ( str1 . index ( 'world' ) ) # 6 # 从右边开始查找 print ( str1 . rindex ( "o" ) ) # 7 print ( str1 . find ( 'llo' ) ) # 2 print ( str1 . find ( 'safa' ) ) # -1 # rfind()从右边开始查找,返回下标 print ( str1 . rfind ( "w" ) ) # 6isdigit()/isdecimal() 判断字符串是否是纯数字
str1 = 'hashlaf456h' print ( str1 . isdigit ( ) ) # False print ( str1 . isdecimal ( ) ) # False str2 = '4564644' print ( str2 . isdigit ( ) ) # True print ( str1 . isdecimal ( ) ) # True print ( str1 )isalpha 判断是否是纯英文
str1 = 'hello,world!' print ( str1 . isalpha ( ) ) # False str2 = 'gkgfkakfhahfl' print ( str2 . isalpha ( ) ) # Truestartswith 判断是否是以某元素开头
str1 = 'hello world!' print ( str1 . startswith ( 'hello' ) ) # Trueendswith 判断是否是以某元素结尾
str1 = 'hello,world!' print ( str1 . endswith ( 'ld!' ) ) # Trueislower 判断英文字母是否全为小写
str1 = 'hsafhl434hsalfh' print ( str1 . islower ( ) ) # Trueisupper 判断英文字母是否全为大写
str1 = 'KSFGKFGS,.,.' print ( str1 . isupper ( ) ) # True str2 = '41343' print ( str2 . isupper ( ) ) # Falseistitle() 判断字符串是否只有是字母是大写
str1 = "Gjpdsjfs464" print ( str1 . istitle ( ) ) # True str2 = "GKG4674dsafa" print ( str2 . istitle ( ) ) # False # 如果其中有特殊字符则为False str3 = "Gjf;aj88**fsaf" print ( str3 . istitle ( ) ) # False -
改： 字符串是不可变类型，下面的修改方法是生成新的序列
upper： 将英文全部修改为大写str1 = 'hello,world!' print ( str1 . upper ( ) ) # HELLO,WORLD!lower： 将英文全部修改为小写
str1 = 'GHSAGKaskhfa' print ( str1 . lower ( ) ) # ghsagkaskhfastrip (lstrip/rstrip) 消除字符串两端无用的空格，lstrip，只消除左端的，rstrip，只消除右端的
str1 = ' hhflahfn hlhaf ahflh hah ' print ( str1 . strip ( ) ) # hhflahfn hlhaf ahflh hah print ( str1 . lstrip ( ) ) # hhflahfn hlhaf ahflh hah print ( str1 . rstrip ( ) ) # hhflahfn hlhaf ahflh hahsplit :分割字符串,以列表的形式输出，不写默认以空格分隔
str1 = 'hello world, today is nice day!' print ( str1 . split ( ' ' ) ) # ['hello', 'world,', 'today', 'is', 'nice', 'day!'] print ( str1 . split ( ) ) # ['hello', 'world,', 'today', 'is', 'nice', 'day!'] print ( str1 . split ( ',' ) ) # ['hello world', ' today is nice day!']title：将字符串的每个单词首字母大写
str1 = "hello world!" print ( str1 . title ( ) ) # Hello World!eveal() 将可以是表达式的字符串转换成有效的表达式
str1 = "1 + 1" print ( eveal ( str1 ) ) # 2“+” 拼接
str1 = "hello" str2 = " world" print ( str1 + str2 ) # hello worldstr1.join(str2)拼接字符串,join()的实际意义是将str1分隔插入到str2中
str1 = '' str2 = [ "h" , "e" , "l" , "l" , "o" ] print ( str1 . join ( str2 ) ) # hello str3 = "+" str4 = "world" print ( '' . join ( str4 ) ) # world print ( str3 . join ( str4 ) ) # w+o+r+l+dswapcase(),将字符串中的字母大写变小写，小写变大写
s = "HHEldf46546fGILGfa" print ( s . swapcase ( ) ) # hheLDF46546FgilgFAcapitalize(),将字符串的首单词大写，其他全部小写
str1 = "dsHFSJHLdshlf" print ( str1 . capitalize ( ) ) # Dshfsjhldshlford()将单个字母根据assic码转换成对应的数字，chr():将单个数字根据assic码转换成相应的字母
str1 = 65 print ( chr ( str1 ) ) # A 这里数字和字母对应的assic码为： a-z : 97-122 A-Z:65-90 str2 = "B" print ( ord ( str2 ) ) # 66str1.center(length,str2) 将字符串str1居中放置到str2中，整个字符串长度为length，不够的用str2填充
str1 = "hello" print ( str1 . center ( 20 , "*" ) ) # *******hello********replace(old,new)替换
str1 = "h e l l o" print ( str1 . replace ( " " , "" ) ) #hello print ( str1 . replace ( "o" , "o ,world" ) ) # h e l l o ,worldstr.maketrans() translate()映射替换
#1、使用 str.maketrans()函数生成一个数据关系映射表 t = str . maketrans ( "abcdef" , "123456" ) # 两个字符串的字符长度要对应，否则报错 str1 = "bdce" #将映射表放入函数中 print ( str1 . translate ( t ) ) # 2435字符串的编码encode解码decode(主要针对中文)
str1 = "hello" # 默认编码方式为 utf8 # 编码 print ( str1 . encode ( ) ) # b'hello' str2 = "你好" print ( str2 . encode ( ) ) # b'\xe4\xbd\xa0\xe5\xa5\xbd' str3 = b '\xe4\xbd\xa0\xe5\xa5\xbd' # 解码 print ( str3 . decode ( ) ) # 你好 print ( str2 . encode ( ) . decode ( ) ) # 你好 str4 = "今天天气不错！" s = str4 . encode ( "GBK" ) print ( s ) # b'\xbd\xf1\xcc\xec\xcc\xec\xc6\xf8\xb2\xbb\xb4\xed\xa3\xa1' print ( s . decode ( ) ) #报错 UnicodeDecodeError: 'utf-8' codec can't decode byte 0xbd in position 0: invalid start byte # 以gbk编码，不写解码方式，默认以utf8解码，故会报错 print ( s . decode ( "gbk" ) ) # 今天天气不错！待更新！！！
