Python3常用基础一

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
  3.复数（complex）：即虚数，1 + 2j，表示方法和数学上差不多，较少用到
• 空值 （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} 用{}表示，以逗号隔开
• 二进制数据类型（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])  #  2
  

  count 查找某元素在序列中的个数

  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
  print(id(list1[1]),id(list2[1)) # 2889423756296 2889423756296
  print(id(list1[1]) == id(list2[1])) # True
    
  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
  一维列表：一个列表发生改变，另外一个列表不会随着发生改变
  多维列表：列表中的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))  # 1
  

  len求长度/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 10
  

  sort 排序

  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'))  #  2
  

  index /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"))  # 6
  

  isdigit()/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())   # True
  

  startswith 判断是否是以某元素开头

  str1 = 'hello world!'
  print(str1.startswith('hello')) # True
  

  endswith 判断是否是以某元素结尾

  str1 = 'hello,world!'
  print(str1.endswith('ld!'))  # True
  

  islower 判断英文字母是否全为小写

  str1 = 'hsafhl434hsalfh'
  print(str1.islower())  # True 
  

  isupper 判断英文字母是否全为大写

  str1 = 'KSFGKFGS,.,.'
  print(str1.isupper())  # True
  str2 = '41343'
  print(str2.isupper())  # False
  

  istitle() 判断字符串所有单词首字母是否大写

  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())   # ghsagkaskhfa
  

  strip (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  hah
  

  split :分割字符串,以列表的形式输出，不写默认以空格分隔

  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 world
  

  str1.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+d
  

  swapcase(),将字符串中的字母大写变小写，小写变大写

  s = "HHEldf46546fGILGfa"
  print(s.swapcase())  # hheLDF46546FgilgFA
  

  capitalize(),将字符串的首单词大写，其他全部小写

  str1 = "dsHFSJHLdshlf"
  print(str1.capitalize())  # Dshfsjhldshlf
  

  ord()将单个字母根据assic码转换成对应的数字，chr():将单个数字根据assic码转换成相应的字母

  str1 = 65
  print(chr(str1))  # A   这里数字和字母对应的assic码为： a-z : 97-122   A-Z:65-90
  str2 = "B"
  print(ord(str2))  # 66
  

  str1.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 ,world
  

  str.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"))     # 今天天气不错！
  

  待更新！！！