python基础

编程学习必备！一张图带你从小白开始学python！Python是一种跨平台的计算机程序设计语言。 是一个高层次的结合了解释性、编译性、互动性和面向对象的脚本语言。最初被设计用于编写自动化脚本(shell)，随着版本的不断更新和语言新功能的添加，越多被用于独立的、大型项目的开发。还不快收藏学起来！

1.python基础

• 代码格式
  • #开头是注释,申明Python环境，申明编码格式
  • 语句以：结尾，缩进语句为代码块
  • 缩进单位：四个空格
  • 大小写敏感
  • 注释
    • 单行注释#
    • 多行注释 """ 被注释部分 """
• 数据类型和变量
  • 整数
    • 大小没有限制
  • 浮点数
  • 字符串
    • 以单引号‘’或双引号“”括起来的任意文本
  • 转义字符
    • 换行：\n
    • 制表符：\t
    • \ ：\\
  • 布尔值
    • True
    • False
  • 空值
    • None，不可以理解为0
  • 运算符
    • 运算顺序
      • ( ) > not > and > or
    • 算术运算符
      • - * / ** %
    • 比较运算符
      • (等于) != (不等于)
    • 赋值运算符
      • 赋值 自加 -= 自减 *= 自乘 /= //= **= %
    • 逻辑运算符
      • and (与/和) or （或） not （非）
    • 成员运算符
      • in not in
  • 数据类型总结
    • 可变: list ,dict ,set 不可变: int bool str tuple 有序: list,tuple,str,int,bool 无序: dict,set 取值方式: 索引: str list tuple 直接: set ,int ,bool 键: dict
  • 变量
    • 变量命名规则
      • 由数字、字母、下划线组成，且不能是数字开头
      • 不能是Python关键字
      • 变量名要见名知意，具有可识别性
      • 驼峰式 ShopCar 下划线分割 Shop_Car
    • 可以是数字或任意数据类型
      • a = 1
      • t_007 = 'T007'
      • Answer=True
  • 常量
    • 通常用大写变量名表示常量
      • PI=3.14159265359
• if条件判断
  • 条件判断为True，执行缩进语句
  • else语句：if判断为False，则执行else语句
  • 多重判断，用elif
  • 循环嵌套
    • if <条件判断1>: if <条件判断2>: 执行1> else: 执行2> else: 执行3
• for和while循环
  • for...in循环，依次把list或tuple中的每个元素迭代出来
  • while循环，只要条件满足，就不断循环，条件不满足时退出循环
    • break
      • while True: print(A) print(B) break #终止当前循环 break下方的代码不执行 print(C) print(D)
    • continue
      • while True: print(A) print(B) continue #伪装成临时当作循环体中的最后一行代码(跳出当前循环继续下一个循环) #下面代码不会执行 print(C) print(D)
• 字符串和编码
  • 字符编码
    • ASCII编码
      • 1个字节
        • A:0100 0001
    • GB2312编码
      • 英文1字节，中文2字节
    • Unicode编码
      • 英文2个字节 中文4字节
        • A: 0000 0000 0100 0001
    • UTF-8编码
      • 英文1字节 欧文2字节 中文3字节
        • 可变长编码，根据不同数字大小变成1-6个字节
  • 字符串
    • 字符串函数
      • ord()：获取字符在编码表中的位置
        • ord('a') --->97 ord('万') --->19975
      • chr()：编码表中的位置对应的字符
        • chr(65) --->'A' chr(26102) --->‘时’
    • 类型
      • str
      • repr
    • 格式化
      • 用%实现
        • 'Hello,%s' %'world'
          • 'Hello, world'
        • 'Hi, %s, you have $%d.' %('Michael', 10000)
          • 'Hi, Michael, you have $1000000.'
        • 常见占位符
          • 整数 %d
          • 浮点数 %f
          • 字符串 %s
          • 十六进制整数 %x
          • %：%%
      • format()
        • format()传入参数一次替换字符串内的占位符{0}、{1}...
          • 'Hello, {0}, 成绩提升了 {1:.1f}%'.format('小明', 17.125)
      • Py3.6以后的实现f'X'(推荐)
        • name = "Alex" age = 25 print(f"姓名：{name}，年龄：{age}")
    • 常用操作
      • 索引
      • 切片
        • A = 'alexalexalex' a1 = A[:] #全部取出 a2 = A[1:3] #[1,3),取不到3 a3 = A[4:] #4到结尾，且能取到结尾 a4 = A[:4] #从开头到4，取不到4
      • 步长
        • A = 'alexalexalex' a1 = A[1:6:2] print(a1)
      • A = 'alexalexalex' A1 = ' alex alex alex ' A2 = '###alex alex alex###' upper 全部大写A.upper( ) lower 全部小写A.lower( ) startswith 判断以什么开头A.startswith('a') --->True endswith 判断以什么结尾A.endswith('x') --->True count 统计(计数,出现了几次)A.count('a') --->3 strip 脱: 头尾两边端的空格,换行以及制表符, 可以自己指定print(A2.strip('#')) --->默认是除去空格、换行和制表符，可以传参指定要去除的内容，衍生方法还有A2.rstrip('#')和A2.lstrip('#') split 分割: 以空格,换行以及制表符进行分割,可以自己指定,可以指定切割的次数print(A.split('x')) --->['ale', 'ale', 'ale', ''] replace 替换: 第一个旧的值,第二是个新的值,可以指定替换的次数 A.replace('a','A') --->AlexAlexAlex capitalize，首字母大写 swapcase，大小写反转 center，居中 A3 = 'NameError' A3.center(20,'-') --->'-----NameError------' 查找，从左往右，返回第一个匹配到的元素的index号 find --->没找到返回-1 index --->没找到抛异常，ValueError: substring not found join，拼接 name = "alex" print("_".join(name)) --->'a_l_e_x' title 标题，每个单词首字母大写A1.title() ---> Alex Alex Alex len 计算长度len(A) --->12
      • is系列
        • str.isdigit # 判断是不是阿拉伯数字
        • str.isdecimal # 判断是不是十进制数
        • str.isalnum # 判断是不是字母,数字,汉字
        • str.isalpha # 判断是不是字母,中文
• 列表和元组
  • 列表
    • 是一种有序的集合，可随时添加和删除其中元素，用[]表示
      • classmates = ['Michael', 'Bob', 'Tracy']
    • 索引、切片
      • 从0开始
        • classmates[1]
      • 最后一个可以用-1索引
        • classmates[-1]
    • 常见操作
      • len()：获取元素个数
      • 增
        • append 末尾追加
          • lst = ['A', 'B', 'C'] lst.append('D') lst --->['A', 'B', 'C', 'D']
        • insert 指定位置追加
          • lst = ['A', 'B', 'C'] lst.insert(2,'B1') lst --->['A', 'B', 'B1', 'C']
        • extend 迭代添加
          • lst = ['A', 'B', 'C'] lst.extend('XYZ') lst --->['A', 'B', 'C', 'X', 'Y', 'Z']
      • 删
        • lst = ['A', 'B', 'C', 'X', 'Y', 'Z'] del是一个函数，或者是一个方法，并不是列表特有的方法 del lst -- 删除整个列表 del lst[0] -- 通过索引删除lst --->['B', 'C', 'X', 'Y', 'Z'] del lst[1:2] -- 切片删除 del lst[1:4:2] -- 步长删除
        • clear 清空列表，clear是列表的一个方法
          • lst = ['A', 'B', 'C', 'X', 'Y', 'Z'] lst.clear() lst --->[ ]
        • remove 通过元素进行删除
          • lst = ['A', 'B', 'C', 'X', 'Y', 'Z'] lst.remove('B') lst --->['A', 'C', 'X', 'Y', 'Z']
        • pop
          • 1、默认删除最后一个，可以指定索引号删除 2、有返回值，返回的是被删除的元素 3、通过索引进行删除
            • lst = ['A', 'B', 'C', 'X', 'Y', 'Z'] POP1 = lst.pop(3) print(POP1) --->X
      • 改
        • 对相应索引位置的切片进行重新赋值
          • lst = ['A', 'B', 'C', 'X', 'Y', 'Z'] lst[1:4]='BB1','CC1','DD1','EE1' print(lst) --->['A', 'BB1', 'CC1', 'DD1', 'EE1', 'Y', 'Z'] lst[1:4]='B1' print(lst) --->['A', 'B', '1', 'Y', 'Z'] lst[:4:2]='BB1','CC1' print(lst) 1、假如索引切片没有修改默认步长，不论待赋值的元素个数是大于还是小于索引切片的个数，均可以完成操作 2、假如索引切片时修改了默认步长，则需要1：1对应，比如：索引切片了2个元素，则需要新赋值两个元素
      • 查
        • for i in lst: print(i)
      • 其他操作
        • sort 排序
          • A = [1,6,9,2942,54,135,43,2,16,543] A.sort() #升序 print(A) --->[1, 2, 6, 9, 16, 43, 54, 135, 543, 2942] A.sort(reverse=True) #降序 print(A) --->[2942, 543, 135, 54, 43, 16, 9, 6, 2, 1]
        • reverse 反转
          • A = [1,6,9,2942,54,135,43,2,16,543] A.reverse() print(A) --->[543, 16, 2, 43, 135, 54, 2942, 9, 6, 1]
    • list内部数据类型可以不同
      • L = ['Apple', 123, True]
      • 元素可以是另一个list(嵌套)
        • s = ['python', 'java', ['asp', 'php'], 'scheme']
  • 元组
    • 另一种有序列表叫元组，初始化后不能改变，用()表示 只能索引查看和for查看,不能进行增删改
      • classmates = ('Michael', 'Bob', 'Tracy')
    • 空tuple
      • t = ()
      • 初始化 t = tuple()
    • 一个元素tuple
      • t = (1,)
    • 可变tuple
      • tuble内部包含list
        • t = ('a', 'b', ['A', 'B'])
        • tup = ('ABC', ['A', 'B', 'C'], 'XYZ') tup[1][1] = 'B1' tup --->('ABC', ['A', 'B1', 'C'], 'XYZ')
• 字典和集合
  • dict
    • 使用键-值{key:value}存储, 用大括号表示{ } 无序的,可变的 键:使用不可变数据类型(可哈希),键是唯一的 值:可以任意
      • d = {'Michael': 95, 'Bob': 75, 'Tracy': 85}
    • 增
      • 初始化赋值
      • 通过key赋值
        • d['Jack'] = 90
      • dic = {'HostName':'SW1', 'NIC':'Eth0', 'IP':'192.168.1.1', 'NetMask':'255.255.255.0'} dic['Protocol'] = 'BGP' dic.setdefault('IP','192.168.2.1') print(dic) --->{'HostName': 'SW1', 'NIC': 'Eth0', 'IP': '192.168.1.1', 'NetMask': '255.255.255.0', 'Protocol': 'BGP'} dic['Key'] --->暴力添加，如果Key存在，直接更改 dic.setdefault('key',value) --->如果键不存在，之间增加，如果键存在，则不改变
    • 删
      • pop(key)
        • dic.pop('Bob')
      • popitems( )
        • 随机删除并返回字典中的一对键和值（项）
      • clear( )
        • dic.clear( )变成空字典
      • del函数删除
        • del dic
    • 改
      • dic['key']=value 将原先的key重新赋值
        • dic['NIC'] = 'Eth1'
      • dic.update( ) 将一个字典，update进另一个字典
        • dic = {'HostName':'SW1', 'NIC':'Eth0', 'IP':'192.168.1.1', 'NetMask':'255.255.255.0'} dic1 = {'Protocol':'BGP'} dic.update(dic1)
    • 查
      • for 循环查询字典的键
      • dic.get('key')通过get字典的key，返回key对应的value
        • A = dic.get('NIC') --->Eth0
    • 其他方法
      • fromkeys 将序列（列表、元组）里面的元素转换为字典里面的Key
        • seq = ('Google', 'Runoob', 'Taobao') dic1 = dict.fromkeys(seq) print(dic1) --->{'Google': None, 'Runoob': None, 'Taobao': None} lst = ['HostName', 'NIC', 'IP'] A = dict.fromkeys(lst,'key') print(A) --->{'HostName': 'key', 'NIC': 'key', 'IP': 'key'} dic = {} dic.fromkeys("123",[23]) print(dic) --->{"1":[23],"2":[23],"3":[23]}
  • set
    • set和dict类似，也是一组key的集合，但不存储value 没有值的字典 无序 -- 不支持索引 天然去重
      • s = set([1, 2, 3])
    • 增
      • add(key)
      • update('字符串')迭代增加
    • 删
      • remove(key) 删除对应的key
      • pop( ) 不需要传参，随机删，有返回值
      • clear( ) 清空集合
    • 改
      • 先删再改
    • 查
      • for循环查找
    • 其他操作
      • 交集
      • 并集
      • 差集
      • 反交集
      • 超集
      • 子集
      • 冻结集合
• 小数据池和深浅拷贝
  • 小数据池
    • 范围：-5 - 256
    • a = 256 b = 256 print(a is b) --->True print(id(a)) --->94041455240928 print(id(b)) --->94041455240928 a = 257 b = 257 print(a is b) --->False print(id(a)) --->140180061122352 print(id(b)) --->140180061120560
    • 总结： 小数据池作用：缓存机制、驻留机制 不同的Python环境（Pycharm、Linux、Jupyter、Anaconda）等等，小数据池机制不一样 总的来说，一定范围内的数字、字符串等，不同变量的内存ID一样
  • *深浅拷贝
    • 示例1： lst = [1,2,3,[5,6,7]] lst1 = lst print(id(lst)) --->4503520832 print(id(lst1)) --->4503520832 lst1[3][2] = 8 print(lst) --->[1, 2, 3, [5, 6, 8]] print(lst1) --->[1, 2, 3, [5, 6, 8]]
    • 浅拷贝 copy
      • 示例2： lst = [1,2,3,[5,6,7]] lst1 = lst.copy() lst1[-1].append(8) print(lst) --->[1, 2, 3, [5, 6, 7, 8]] print(lst1) --->[1, 2, 3, [5, 6, 7, 8]] lst1.append(9) print(lst) --->[1, 2, 3, [5, 6, 7, 8]] print(lst1) --->[1, 2, 3, [5, 6, 7, 8], 9]
    • 深拷贝 deepcopy
      • 示例3： import copy lst = [1,2,3,[5,6,7]] lst1 = copy.deepcopy(lst) lst1[-1].append(8) print(lst) --->[1, 2, 3, [5, 6, 7]] print(lst1) --->[1, 2, 3, [5, 6, 7, 8]]
    • 总结: 浅拷贝的时候只拷贝第一层元素 浅拷贝在修改第一层元素(不可变数据类型)的时候,拷贝出来的新列表不进行改变 浅拷贝在替换第一层元素(可变数据类型)的时候,拷贝出来的新列表不进行改变 浅拷贝在修改第一层元素中的元素(第二层)的时候,拷贝出来的新列表进行改变 深拷贝开辟一个容器空间(列表),不可变数据公用,可变数据数据类型(再次开辟一个新的空间),空间里的值是不可变的数据进行共用的,可变的数据类型再次开辟空间
• 文件操作
  • file 文件路径，注意转义，文件路径前加r，取消转义 mode 操作文件的模式（r w a rb wb ab r+ w+ a+） encoding 编码格式
  • open 打开文件
  • 操作文件
    • r 读文本
      • A = open('L01.ipynb',mode='r',encoding='utf-8') A.read() --->全部读取，拼接在一起，整合为一个字符串 A.readline() --->读取一行 A.readlines() --->按行读取，一行为一个字符串
    • w 清空，写文本
      • A = open('test.txt',mode='w',encoding='utf-8') --->清空 A.write('Name is Alex\n') --->只能写文本，并将文本写入test.txt中
    • a 追加
      • A = open('test.txt',mode='a',encoding='utf-8') --->不会被清空 A.write('Name is Alex1\n') --->追加写入
    • rb 读字节
      • 方法和r一样，只是读出来的是字节，可用于非文本文件的copy
    • wb，清空，写
    • ab 追加
    • r+
    • w+
    • a+
  • close 关闭文件
  • with open
    • with open("文件路径","操作模式",编码")as f: 操作文件 with open的好处: 1.可以同时打开多个文件 2.能够自动关闭文件