Python基础（2.3w字，无一废话）---最新更新2021.7.18

如有错误，感谢指正

如有错误，感谢指正，请私信博主，有辛苦红包，拜“一字之师”。

当你越来越漂亮时，自然有人关注你。当你越来越有能力时，自然会有人看得起你。改变自己，你才有自信，梦想才会慢慢的实现。做最好的自己，懒可以毁掉一个人，勤可以激发一个人！不要等夕阳西下的时候才对自己说，想当初、如果、要是，之类的话！不为别人，只为做一个连自己都羡慕的人。

请根据目录寻找自己需要的段落

导语：本博客为个人整理Python学习帖，如有错误，感谢指正。系统学习，欢迎持续关注，后续会涉及自动化办公，爬虫，python大数据，算法，人工智能基础—对接AI。欢迎关注，python基础阶段结束，会更新AIOT相关博客，欢迎大家讨论相关AIOT技术，如有大佬愿意加入团队，欢迎私信。

注：关于以下文字中涉及的伪代码或者代码中，有部分参数会被（[ ]）所包括着，含义为可有可无，可类比重载。

结课作业

小白请看完基础操作后再看这份作业python结课作业，学生管理系统

入门

print()内置函数

print(520)           # 打印整型数字
print(98.5)         # 打印浮点型
print('hello world')  # 字符串可以用单引号包括，也可以用双引号包括
print("hello world!")
print(3+1)         # 打印表达式print('hello world ', 'python', 'java')        # 字符串的连接
# 转义字符\
print('hello\nworld')     # \n 换行
print('hello\tworld')     # \t 制表符
print('hello\rworld')     # \r 光标回退到行首
print('hello\bworld')     # \b 光标回退一位
print("http:\\\\www.baidu.com")   # \\ 打印\
print("老师说：\'大家好！\'") # \' 打印' \的作用就是打印被标记特殊含义的符号，按照原本的样子打印出来 # 原字符 前面加R or r   最后一个字符不能是\
print(r'hello\n world')       # 打印结果为 hello\n world ，将str原原本本的打印出来

input()内置函数

# input()
present = input('大声说出什么编程语言天下第一')
print(present, type(present))
a = input('请输入一个加数')
b = input('请输入另一个加数')
print(int(a) + int(b))
a = int(input('请输入一个加数'))
b = int(input('请输入另一个加数'))
print(a + b)

二进制

二进制与字符编码二极管的物理特性决定了计算机的二进制计算特性
8位bit 一字节 byte 1024 kb mb gb tb
8位 256个状态一个状态对应一个字符 ASCII表
由于不够用，所以有了字符编码，每个国家基本都有，GBK GB18030 Unicode码 UTF-8

不同进制表示方法
二进制 0b
八进制 0o
十进制
十六进制 0x

标识符与保留字

标识符（变量、常量、函数、语句块等）与保留字（看我C语言那章的介绍，都一样的概念）
标识符规则数字、字母、下划线构成，不能以数字开头，不能使用保留字，严格区分大小写

import keyword
print(keyword.kwlist)       # 打印保留字

变量

# 变量的定义和使用
# 变量由三部分构成 标识（id（obj））、类型(type(obj))、值(print(obj))
name = 'marry'
print(name)
print(id(name))
print(type(name))# 变量多次赋值，标识符会指向新的内存空间
name = 'Eric'
print(name, id(name))

数据类型

# 常见数据类型
'''
整数类型    int     98
浮点类型    float   3.14159
布尔类型    bool    True    False
字符串类型   str     ‘人生苦短，我用python’
'''# 整型    integer int 正数，负数，0

布尔型和浮点型

# 浮点型
'''整数部分，小数部分组成浮点数存储不精确，使用浮点数计算会出现小数位数不确定的情况解决方案：导入模块decimal
'''
from decimal import Decimal
a = 3.14159
print(a, type(a))
print(1.1+2.2)
print(1.1+2.1)print(Decimal('1.1')+Decimal('2.2'))
print(Decimal('1.1')+Decimal('2.1'))# 布尔类型
'''用来表示真或者假,可以转成整数计算True    ==>1False   ==>0
'''

字符串

# 字符串类型
'''字符串又被称为不可变的字符序列可以使用单引号”’双引号"”三引号"…""…或""""""来定义单引号和双引号定义的字符串必须在一行三引号定义的字符串可以分布在连续的多行
'''str1 = 'aaa'
str2 = "bbb"
str3 = """bbbb
ddd"""print(str1, type(str1))
print(str2, type(str2))
print(str3, type(str3))

数据类型转换

# 类型转换
'''为什么需要类型转换？  答：将不同数据类型进行数据拼接在一起str()   将其他类型转为string类型，也可用引号转换int()   将其他数据类型转成整型，文字类和小数类字符串无法转为整数，浮点数转整数，抹零取整float() 将其他数据类型转浮点型，文字类字符串无法转为整数，整数转浮点数，末尾.0
'''
name = 'Eric'
age = 20
print(type(age), type(name))
print('Im'+name+',now im'+str(age)+'years old')
print(int(True), int(False), int('100'), int(99.32))
print(float(123), float('563.3'), float('156'), float(True))

python的注释

# python中的注释
'''增加可读性，被解释器忽略单行 #开头多行 一对三引号中文编码声明注释， 文件开头加#coding:gbk声明存储格式，python3已经不再需要声明了
'''

运算符

'''常用的运算符算术运算符标准算术运算符 + - * / //(整除)取余运算符 % 幂运算符 **赋值运算符   执行顺序：右--->左     支持链式赋值 a=b=c=20     支持参数赋值（二元运算符+= -= *= /= %= //=）支持系列解包赋值 a, b, c = 10, 20, 30 左右数目需要相等对应比较运算符布尔运算符位运算符
'''
# 算术运算符
print(1+1)
print(5*2)
print(9-7)
print(9/3)
print(9//5)
print(9%5)
print(2**3)# 赋值运算符
# 连续赋值
i = 20
a = b = c = i   # 一个空间，多个引用
print(a, id(a))
print(b, id(b))
print(c, id(c))
print(i, id(i))
a += 10
print(b, id(b))
print(a, id(a))a, b, c = 10, 20, 30
print(a, b, c)

一正一负导致的特殊情况
单拎出来，希望注意

# 一正一负的情况下的一些问题
# 向下取整的情况
print(-9//-4)   # 2
print(9//4)     # 2
print(9//-4)    # -3
print(-9//4)    # -3
# 余数等于被除数-除数*商
print(9 % -4)   # -3
print(-9 % 4)   # 3

比较运算符

# 比较运算 结果 布尔值 >   <   >=  <=  == !=
'''== 比较的是 值is 比较的是对象的标识    比较的是 idis not
'''
print(10 < a < 15) # python 里面可以这样写
lis1 = [11, 22, 33, 44]
lis2 = [11, 22, 33, 44]
print(lis1 == lis2)
print(lis1 is lis2)
print(lis1 is not lis2)

布尔运算符

# 布尔运算 and / or / not / in / not in
s = 'abc'
print('c' in s)
print('c' not in s)

位运算符

# 位运算 & / | / << / >>
print(4 << 1)   # *2
print(4 << 2)
print(4 >> 1)   # /2

运算符优先级

# 算术优先级问题 算术 位 比较 布尔 有括号先算括号
'''（**） >（* / // %）> （+ -） >  （<< >>） > （&） > （|） > （> < >= <= ==  !=）  >  (and)  >  (or)
'''

程序的组织结构

顺序执行

顺序结构：从头到尾顺序执行，没有任何跳转

选择执行

# 学习选择执行结构之前，先讲一下布尔值的判断
# 对象的布尔值    py一切皆对象，每个对象都有一个布尔值     内置函数bool()可查看
# 以下对象布尔值都是false
# False（boolean）
# 数值0/0.0
# None
# 空字符串  ‘’ “”
# 空列表   [] list()
# 空元组   () tuple()
# 空字典   {}  dict()
# 空集合   set()

# 选择结构
# 单分支结构 如果 就
'''if 条件表达式：条件执行体
'''
a = int(input("please input your salary"))
if a > 20:print('you are so good')# 双分支结构 如果  不满足 就
'''if 条件表达式：条件执行体1else：条件执行体2
'''if a > 10:print('you are good')
else:print('you need do more work')# 多分支结构
'''if 条件表达式1：条件执行体1elif 条件表达式2：条件执行体2elif 条件表达式N：条件执行体N[else：]条件执行体N+1
'''
if a < 0:print('0')
elif a < 10:print('1')
elif a < 100:print('2')
else:print('3+')# 嵌套if
'''if 条件表达式1:if 内层条件表达式：内层条件表达式1else：内层条件表达式2else：条件执行体
'''
if 100 > a > 0:if a > 60:print('666')else:print('good')
else:print('good salary')# 条件表达式  代码1 if 判断语句 else 代码2
# 如果条件为 true 执行左边代码    为 false 执行右边代码
print('a>66' if a > 66 else 'a<66')# pass 语句   占位符，等待后面再填写代码，避免pycharm报警
if a > 0:pass

循环执行

# 将循环之前，先学习一个内置函数，一般for循环都要用
# 内置函数 range() 用于生成一个整数序列，返回值是一个迭代器对象（内存空间大小一样，只有用到range对象才会去计算相关元素），in / not in 判断是否在整数序列内
'''range(stop)             创建一个[0,stop)之间的整数序列，步长为1range(start,stop)       创建一个[start,stop)之间的整数序列， 步长为1range(start,stop,step)  创建一个[start,stop)之间的整数序列，步长为step
'''

# 循环结构
'''while 条件表达式：条件执行体（循环体）If是判断一次，条件为True执行一行while是判断N+1次，条件为True执行N次
'''
a = 1
while a < 10:print(a)a += 1# 计算1-100之间偶数和
a = 0
result = 0
while a < 101:if a % 2 == 0:result += aa += 1
print(result)# for-in 循环     遍历可迭代对象 str/序列
'''for 自定义变量 in 可迭代对象:循环体循环体内不需要访问自定义变量，可以将自定义变量替代为下划线
'''for item in 'python':print(item)for i in range(10):print(i)for _ in range(5):print('人生苦短，我学python')for i in range(100, 1000):if (i // 100)**3 + (i // 10 % 10)**3 + (i % 10)**3 == i:print(i)# 流控制语句 break       用于结束循环结构，通常与分支结构中的if一起使用
# 流控制语句 continue    用于结束当前循环，进入下一次循环，通常与分支结构中的if一起使用
# else语句
'''if条件表达式不成立时执行elsewhile/for没有碰到break时执行else
'''
a = 0
while a < 3:pwd = input('请输入密码')if pwd == '8888':print('密码正确')breakelse:print('密码不正确')a += 1
else:print('对不起，三次密码均输入错误')# 嵌套循环  循环结构中又嵌套了另外的完整的循环结构，其中内层循环做为外层循环的循环体执行
for i in range(1, 10):for j in range(1, i+1):print(i, '*', j, '=', i*j, end='\t')print()

列表类比数组

列表简述

# python 一切皆对象（PS：初学者不要去尝试理解， 等写了1w行代码后，你自然会理解的）
# 这里不再赘述基本数据类型
# 列表    相当于 其他语言中的 数组
''' -2      -1 str1    str20       1内存分析：   列表里存的是id数组 id指向内容的对象   ID：内存地址  VALUE:地址那存的值 TYPE:list
'''
a = 10  # 变量存储的是一个对象的引用
lst = ['hello', 'world', 98]
print(id(lst))
print(type(lst))
print(lst)

列表创建

# 列表的创建
'''1、  使用中括号   2、  内置函数list()
'''
lst1 = ['str1', 'str2', 98]
lst2 = list(['str1', 'str2', 98])

列表的特点

# 列表的特点 有序排序
print(lst1[0])
print(lst1[-3])'''列表元素按顺序有序排序索引映射唯一个数据列表可以存储重复数据任意数据类型混存根据需要动态分配和回收内存
'''

列表的查询操作

# 列表查询操作
'''
获取列表中指定元素的索引  index(元素，start，stop)   如查列表中存在N个相同元素，只返回相同元素中的第一个元素的索引如果查询的元素在列表中不存在，则会抛出ValueError还可以在指定的start和stop之间进行查找获取列表中的单个元素正向索引    0》》n-1逆向索引    -n》》-1索引不存在，抛indexError
'''
print(lst1.index('str1'))
print(lst1.index('str1', 0, 2))print(lst1[0])
print(lst1[-3])

切片操作
下面的题，自己可以猜一下，跑一下看看对不对

'''
切片操作：获取多个元素     列表名[start：stop：step]切片的结果        原列表片段的拷贝切片的范围        [start,stop)step默认为1      简写为[start:stop]step为正数       [:stop:step]         切片的第一个元素默认是列表的第一个元素        从start开始往后计算切片[start::step]       切片的最后一 个元素默认是列表的最后一 个元素step为负数       [:stop:step]         切片的第一个元素默认是列表的最后一个元素        从start开始往前计算切片[start::step]         切片的最后一个元素默认是列表的第一个元素
'''
lst3 = [10, 20, 30, 40, 50, 60, 70, 80, 90]
print(lst3[1:6:1])
lst4 = lst3[1:6:1]
print(lst4)print(lst3[1:6])
lst4 = lst3[1:6]
print(lst4)print(lst3[1:6:2])
lst4 = lst3[1:6:2]
print(lst4)print(lst3[:6:2])
lst4 = lst3[:6:2]
print(lst4)print(lst3[1::2])
lst4 = lst3[1::2]
print(lst4)print(lst3[::-1])
lst4 = lst3[::-1]
print(lst4)print(lst3[7::-1])
lst4 = lst3[7::-1]
print(lst4)print(lst3[:7:-1])
lst4 = lst3[:7:-1]
print(lst4)

列表的遍历和判断元素是否存在

# 判断指定元素在列表中是否存在    in / not in
print('str1' in lst1)
print('str1' not in lst1)# 列表元素的遍历 for-in
for item in lst1:print(item)

列表的增删改查、排序操作

'''
增append()    在列表的木尾添加一个元素extend()    在列表的末尾至少添加一个元素insert()    在列表的任意位置添加一个元素切片  在列表的任意位置添加至少一个元素
'''
print(lst3, id(lst3))
lst3.append(100)
print(lst3, id(lst3))
lst3.extend(lst2)
print(lst3, id(lst3))
lst3.append(lst2)
print(lst3, id(lst3))
lst3.insert(1, 90)
print(lst3, id(lst3))
lst2 = ['hello', 'world', 65]
lst3[3:] = lst2
print(lst3, id(lst3))'''
删一次删除一个元素remove()    重复元素只删除第一个元素不存在抛出ValueError删除一个指定索引位置上的元素pop()   指定索引不存在抛出IndexError 不指定索引，删除列表中最后一个元素切片  一次致少删除一个元素,将产生一个新的列表clear() 清空列表del 删除列表对象
'''
lst5 = [10, 20, 30, 40, 50, 60, 70, 80, 90, 20]
lst5.remove(20)
print(lst5)lst5.pop(1)
print(lst5)
lst5.pop()
print(lst5)lst6 = lst3[1:3]
print(lst6)lst5[1:3] = []
print(lst5)lst6.clear()
print(lst6)del lst6'''
修改列表元素的修改操作为指定索引的元素赋予一个新值为指定一个切片赋予一个新值
'''
print(lst5)
lst5[2] = 10
print(lst5)
lst5[1:3] = [300, 400, 5000, 600]
print(lst5)# 排序 sort() / 内置函数sorted()      默认升序 ，设置reverse=True实现降序
lst5.sort()
print(lst5)lst5.sort(reverse=True)
print(lst5)new_lst = sorted(lst5)
print(new_lst)new_lst = sorted(lst5, reverse=True)
print(new_lst)

列表生成式

# 列表生成式 [i*i(列表元素表达式) for i in range(1,10)]new_lst = [i for i in range(1, 10)]
print(new_lst)new_lst = [i*i for i in range(1, 10)]
print(new_lst)new_lst = [i*2 for i in range(1, 6)]
print(new_lst)

字典类比map

# 字典 dic {} 和列表一样是可变序列，以键值对的方式存储数据，字典是一个无序的序列
# scores={'allen':100, 'zhangSan':50, 'liSi':80}    hash函数计算key存放，key-value，key必须是不可变序列（str，不可增删改，不可变序列）# 字典的创建 = / 内置函数dict()
scores1 = {'allen': 100, 'zhangSan': 50, 'liSi': 80}
scores2 = dict(name='allen', age=20)
print(scores1)
print(type(scores1))
print(scores2)
d = {}
print(d)# 获取数据  [key] / get(key)
print(scores1['allen'])         # 不存在报错KeyError
print(scores1.get('zhangSan'))  # 不存在返回none     或设置返回 99# key的判断    in / not in
print('allen' in scores1)
print('zhangSan' not in scores1)# 删除 del 清空clear()
del scores1['zhangSan']
print(scores1)
scores1.clear()
print(scores1)# 新增    没有新增，有就更改
scores1['allen'] = 99
print(scores1)
scores1['allen'] = 98
print(scores1)# 获取字典视图
'''keys()      获取字典中所有keyvalues()    获取字典中所有valueitems()     获取字典中所有key,value对
'''
keys = scores2.keys()
print(keys)
print(type(keys))
print(list(keys))values = scores2.values()
print(values)
print(type(values))
print(list(values))items = scores2.items()
print(items)
print(type(items))
print(list(items))# dict元素的遍历
for item in scores2:print(item)# 字典的特点
'''字典中的所有元素都是一个key-value对, key不允许重复,value可以重复字典中的元素是无序的字典中的key必须是不可变对象字典也可以根据需要动态地伸缩字典会浪费较大的内存，是一种使用空间换时间的数据结构
'''# 字典生成式
# zip()内置函数 用于将可迭代的对象作为参数，将对象中对应的元素打包成一个元组,然后返回由这些元组组成的列表
items = ['Fruits', 'Books', 'Others']
prices = [99, 98, 97, 96, 95]
# 字典生成式{items.upper(): prices for item,price in zip(items, prices)}
ip = {item.upper(): price for item, price in zip(items, prices)}
print(ip)

元组


# 元组    Python内置的数据结构之一，是一个不可变序列
'''不可变序:字符串、元组不可变序列:没有增、删，改的操作为什么将元组设置成不可变序列：多任务环境下，操作对象不用加锁可变序列:列表（数组）、字典（hashmap）、集合（没有value 的字典）可变序列:可以对序列执行增、删、改操作，对象地址不发生更改
'''# 元组的创建 () / tuple  如果只有一个元素逗号不能省略，空元组创建
t = ('python', 'world', 98)
print(t)
print(type(t))u = tuple(('python', 'world', 98))
print(u)
print(type(u))p = ('python',)
print(p)
print(type(p))l = ()
e = tuple()
print(l)
print(e)# 元组的遍历
print(t[0])
print(t[1])
print(t[2])     # 超出length 报错for item in t:print(item)# 小练习
scores = (("a", 70), ("b", 70), ("c", 70), ("d", 70), ("e", 70))
for index, item in enumerate(scores):print(index + 1, ".", end=" ")for score in item:print(score, end=" ")print()

集合

# 集合    没有value的字典 / 可变数据类型（字典 元组 集合）
s = {2, 3, 4, 5, 6, 7}
print(s)
print(type(s))s = set(range(6))
print(s)s = set([1, 2, 3, 4, 5, 6, 7])
print(s, type(s))s = set((1, 2, 3, 4, 5, 4, 6, 65))
print(s, type(s))s = set('python')
print(s)s = set({'python', 98, 95})
print(s)s = set()
print(s, type(s))s = {}
print(s, type(s))   # dict 不可以这样定义空集合s = {10, 20, 30, 40, 50, 60}
# 集合元素的判断 in / not in
print(10 in s)# 新增操作
s.add(80)   # 一次加一个
print(s)s.update({200, 400, 300})   # 一次至少加一个
print(s)s.update((2001, 4001, 3002))
print(s)s.update([900, 800, 700])
print(s)# 删除
s.remove(50)        # 不存在 抛异常
print(s)
s.discard(50)       # 不存在 不抛异常，存在删，不存在不报错
print(s)
s.pop()             # 可删除任意一个元素，不能指定参数
print(s)
s.clear()
print(s)# 集合之间的关系
# == 判断是否相等 ！=
# 判断子集  a issubset b a是否是b的子集
# 判断超集  a issuperset b
# 是否有交集    a isdisjoint b   没交集是true
s1 = {10, 20, 30}
s2 = {10, 20}
s3 = {30, 40}
print(s1 != s2)
print(s1.issuperset(s2))
print(s2.issubset(s1))
print(s3.isdisjoint(s1))# 集合数据的操作
print(s2.intersection(s1))  # 求交集
print(s2 & s1)  # 求交集print(s1.union(s2))     # 求并集
print(s1 | s2)     # 求并集print(s1.difference(s2))        # 差集 只保留左边有的，右边没有的
print(s1 - s2)        # 差集print(s1.symmetric_difference(s2))  # 对称差集  两边的不一样的都要
print(s1 ^ s2)  # 对称差集# 集合生成式 {i*i for i in range(1, 10)} 将{}修改为[] 就说列表生成式    没有元组生成式
s = {i*i for i in range(1, 10)}
print(s)

字符串超详细驻留机制总结

# 字符串      基本数据类型   不可变的字符序列    ‘’ / “ ” / ‘’‘ ’‘’定义# 字符串的驻留机制
'''仅保存一份相同且不可变字符串的方法，不同的值被存放在字符串的驻留池中,Python的驻留机制对相同的字符串只保留一份拷少石实刨建相同字符串时，不会开辟新空间，而是把该字符串的地址赋给新创建的变量驻留机制（引用计数机制）的几种情况(交互模式)     python的引用计数机制，并不是对所有的数字，字符串，它只对“  [0-9] [a-z] [A-Z]和"_"(下划线)  ”有效，当字符串中由其他字符比如“！ @ # ￥ % -”时字符驻留机制是不起作用的。字符串驻留是一种在内存中仅保存一份相同且不可变字符串的方法。系统维护interned字典，记录已被驻留的字符串对象。对于短字符串，将其赋值给多个不同的对象时，内存中只有一个副本，多个对象共享该副本。长字符串不遵守驻留机制 。（python3.4.3版本中，字符串长度有影响：|python3.8.5及之后版本中，字符串长度没有影响）驻留机制触发范围：字符串长度为0或1时，默认采用驻留机制；字符串长度大于1时，且 字符串中只包含大小写字母、数字、下划线(_) 时，采用驻留机制；       abc% 不符合规范字符串 只在编译时进行驻留，而非运行时 。Python是解释型语言，但是事实上，它的解释器也可以是理解为是一种编译器，它负责将Python代码翻译成字节码，也就是.pyc文件；  对于 [-5,256]之间的整数数字，Python默认驻留 ；用乘法得到的字符串，如果结果长度 <=20且字符串只包含数字、字母大小写、下划线，支持驻留。长度>20，不支持驻留。这样的设计目的是为了保护.pcy文件不会被错误代码搞的过大。sys中的intern方法强制2个字符串指向同一个对象PyCharm对字符串进行了优化处理  原本不驻留的，驻留了字符串驻留机制的优缺点当需要值相同的字符串时，可以直接从字符串池里拿来使用、避免频繁的创建和销毁，提升效率和节约内存，因此拼接字符串和修改字符串是会比较影响性能的。在需要进行字符串拼接时建议使用str类型的join方法，而非＋ ,因为join()方法是先计算出所有字符中的长度，然后再拷贝,只new一次对象，效率要比"+"效率高
'''
a = 'a'
b = "a"
c = '''a'''
print(a, type(a), id(a))
print(b, type(b), id(b))
print(c, type(c), id(c))# 字符串的查询操作
'''index()查找子串substr第一次出现的位置,如果查找的子串不存在时，则抛出ValueErrorrindex()查找子串substr最后一次出现的位置，如果查找的子串不存在时，则抛出ValueErrorfind()查找子串substr第一次出现的位置,如果查找的子串不存在时，则返回-1rfind()查找子串substr最后一次出现的位置,如果查找的子串不存在时，则返回-1
'''
s = 'hello,hello'
print(s.index('lo'))
print(s.rindex('lo'))
print(s.find('lo'))
print(s.rfind('lo'))# 字符串的大小写转换操作的方法
'''upper() 把字符串中所有字符都转成大写字母lower() 把字符串中所有字符都转成小写字母swapcase() 把字符串中所有大写字母转成小写字母，把所有小写字母都转成大写字母capitalize() 把第一个字符转换为大写，把其余字符转换为小写title() 把每个单词的第一个字符转换为大写，把每个单词的剩余字符转换为小写
'''
print(s, id(s))
s1 = s.upper()
print(s1, id(s1))
print(s.swapcase())
print(s1.swapcase())# 字符串内容对齐操作的方法
'''center()居中对齐，第1个参数指定宽度，第2个参数指定填充符,第2个参数是可选的，默认是格,如果设置宽度小于实际宽度则则返回原字符串ljust() 左对齐，第1个参数指定宽度，第2个参数指定填充符,第2个参数是可选的，默认是空格如果设置宽度小于实际宽度则则遐问原学将窜rjust() 右对齐,第1个参数指定宽度，第2个参数指定填充符,第2个参数是可选的，默认是空格如果设置宽度小于实际宽度则则返回原字符串  zfill() 右对齐，左边用0填充,该方法只接收一个参数，用于指定字符串的宽度，如果指定的宽度小于等于字符串的长度，返回字符串本身
'''
print(s.center(20, '*'))
print(s.ljust(20, '*'))
print(s.ljust(20))
print(s.rjust(20, '*'))
print(s.rjust(20))
print(s.zfill(9))
print(s.zfill(20))# 字符串劈分操作的方法
'''从字符串的左边开始劈分，默认的劈分字符是空格字符串,返回的值都是一个列表
split()     以通过参数sep指定劈分字符串是的劈分符通过参数maxsplit指定劈分字符串时的最大劈分次数，在经过最大次劈分之后，剩余的串会单独做为一部分从字符串的右边开始劈分，默认的劈分字符是空格字符串,返回的值都是一个列表
rsplit()    以通过参数sep指定劈分字符串是的劈分符通过参数maxsplit指定劈分字符串时的最大劈分次数，在经过最大次劈分之后，剩余的子串会单独做为一部分
'''
s = 'he|llo|he|llo'
print(s.split('|'))
print(s.split('|', maxsplit=1))
print(s.rsplit('|'))
print(s.rsplit('|', maxsplit=1))# 判断字符串操作的方法
'''isidentifier()  判断指定的字符串是不是合法的标识符isspace()       判断指定的字符串是否全部由空白字符组成(回车、换行，水平制表符)isalpha()       判断指定的字符串是否全部由字母组成isdecimal)      判断指定字符串是否全部由十进制的数字组成isnumeric()     判断指定的字符串是否全部由数字组成isalnum()    判断指定字符串是否全部由字母和数字组成
'''
print(s.isidentifier())
print(s.isspace())
print(s.isalpha())
print('10'.isdecimal())
print(s.isnumeric())
print(s.isalnum())# 其他常用操作
'''
replace()   字符串替换     第1个参数指定被替换的子串，第2个参数指定替换子串的字符串,该方法返回替换后得到的字符串，替换前的字符串不发生变化,调用该方法时可以通过第3个参数指定最大替换次数
join()      字符串的合并    将列表或元组中的字符串合并成一个字符串
'''
s = 'hello,python'
print(s.replace('python', 'java'))
s1 = 'hello,python,python,python'
print(s1.replace('python', 'java', 2))lst = ['hello', 'java', 'python']
print('|'.join(lst))
print(''.join(lst))
print('*'.join('lst'))# 字符串的比较操作
'''运算符: > < == != >= <=    比较规则:首先比较两个字符串中的第一个字符，如果相等则继续比较下一个字符，依次比较下去，直到两个字符串中的字符不相等时，其比较结果就是两个字符串的比较结果，两个字符串中的所有后续字符将不再被比较比较原理:两上字符进行比较时，比较的是其ordinal value(原始值)调用内置函数ord可以得到指定字符的ordinal value。与内置函数ord对应的是内置函数chr,调用内置函数chr时指定ordinal value可以得到其对应的字符== 比较 valueis 比较 id（内存地址）
'''# 字符串的切片操作
'''
字符串是不可变类型,不具备增、删、改等操作
切片操作将产生新的对象
'''print(s[:5])
print(s[6:])
print(s[:5] + '!' + s[6:])
print(s[1:5:1])
print(s[::2])
print(s[::-1])# 格式化字符串      %作占位符 / {}作占位符
print('my name is %s age %d' % ('zhangSan', 20))
print('my name is {0},{0} is age {1}'.format('zhangSan', 20))print('%11d' % 99)
print('%.3f' % 3.1415926)
print('%10.3f' % 3.1415926)
print('{0:.3}'.format(3.1415926))
print('{0:.3f}'.format(3.1415926))# 字符串 编码与解码# 编码
# GBK 一个中文占两个字节
# UTF-8 一个中文占三个字节
s = '海内存知己'
print(s.encode(encoding='GBK'))
print(s.encode(encoding='UTF-8'))
s1 = s.encode(encoding='GBK')
# 解码
print(s1.decode(encoding='GBK'))

函数

# 函数    函数就是执行特定任和以完成特定功能的一段代码
'''函数的作用复用代码隐藏实现细节提高可维护性提高可读性便于调试
'''# 函数的创建和调用
'''def 函数名([输入参数]):函数体[return ***]
'''def calc(a, b):c = a + breturn c# 调用
result = calc(10, 20)
print(result)# 函数的参数传递   实参 / 形参     位置实参 / 关键字实参# 函数参数传递的内存分析
'''
在函数调用过程中，进行参数的传递如果是不可变对象，在函数体的修改不会影响实参的值如果是可变对象，在函数体的的修改会影响到实参的值
'''# 函数的返回值
'''
如果函数没有返回值，return可省略     函数是否需要返回值，视情况来定
函数的返回值，如果是一个直接返回原值如果是多个，返回的结果是元组
'''# 函数参数定义
'''函数定义默认值参数 :  函数定义时，给形参设置默认值，只有与默认值不符的时候才需要传递实参   print（‘abc’, end = '\t'） end 默认值\n个数可变的位置参数:  只能有一个定义函数时，可能无法事先确定传递的位置实参的个数时，使用可变的位置参数使用*定义个数可变的位置形参结果为一个元组个数可变的关键字形参: 只能有一个定义函数时，无法事先确定传递的关键字实参的个数时，使用可变的关键字形参使用**定义个数可变的关键字形参结果为一个字典既有个数可变的关键字形参和个数可变的位置形参，要求 个数可变的位置参数在前面关键字形参 *分割 print（a,b,*,c,d） c d 只能用关键字形参传参
'''# 变量的作用域，局部变量，全局变量# 递归函数    （简单说就说自己调自己）  组成：递归调用与递归终止条件
# 递归的调用过程
#   每递归调用一次函数，都会在栈内存分配一个栈帧,
#   每执行完一次函数，都会释放相应的空间
# 递归的优缺点
#   缺点:占用内存多，效率低下
#   优点:思路和代码简单

python异常机制

常见产生异常的原因


# the origin of bug# 常见bug类型
# 粗心
'''漏了末尾的冒号，如if语句,循环语句,else子句等缩进错误，该缩进的没缩进，不该缩进的瞎缩进把英文符号写成中文符号，比如说:引号，冒号，括号字符串拼接的时候，把字符串和数字拼在一起没有定义变量，比如说while的循环条件的变量“==”比较运算符和”=”赋值运算符的混用
'''# 知识点不熟练
'''索引越界append方法不熟练
'''# 思路不清导致的问题
'''使用print打印输出使用 注释 暂时注释掉部分代码
'''

# abnormal# python异常处理机制
# Python提供了异常处理机制，可以在异常出现时即时捕获然后内部“消化"，让程序继续运行# 被动掉坑
'''
try:代码
except Error类型名：（多个except结构，从小到大）打印输出代码
代码
''''''如果try块中没有抛出异常，则执行else块，如果try中抛出异吊，则执行except块
try:代码
except error :代码
else:代码
''''''finally块无论是否发生异常都会被执行，能常用来释放try块中申请的资源
try:代码
except error :代码
else:代码
finally:代码
'''# 常见的异常
'''
ZeroDivisionError   除(或取模)零(所有数据类型)
lndexError  序列中没有此索引(index)
KeyError    映射中没有这个键
NameError   未声明/初始化对象(没有属性)
syntaxError Python语法错误
ValueError  传入无效的参数
'''# traceback模块   打印异常信息
# import traceback
# except：       traceback.print_exc()

面向对象类与对象

# 面向对象
# 不敢乱说
# 面向过程与面向对象
# 不敢开说# 类与对象
# 类的创建
'''     pass 占位符
class Student:  每个单词首字母大写   开辟内存地址，类型：classdef __init__(self,***)  构造方法    初始化 实例属性    构造方法就是在实例化时自动调用类属性     静态属性        当类属性与实例属性同名时，一个实例访问这个属性时实例属性会覆盖类属性，但类访问时不会实例方法        # 类外定义的是函数，类内定义叫方法静态方法    @staticmethod类方法      @classmethod   该方法的第一个参数总是定义该方法的类对象。类方法的第一个形参被命名为 cls类属性:类中方法外的变量称为类属性，被该类的所有对象所共享       类方法:使用@classmethod修饰的方法，使用类名直接访问的方法         类方法，就是用类名直接调用的，不需要实例化类方法可以访问类属性，无法访问实例属性静态方法:使用@staticmethod修饰的主法，使用类名直接访问的方法   有@staticmethon修饰，没有 cls 和 self 参数限制的方法我们称之为静态方法。 静态方法主要是用来存放逻辑性的代码，主要是一些逻辑属于类，但是和类本身没有实际性的交互，但是需要让这个功能成为这个类的成员，那么就可以采用静态方法。在静态方法中，不会涉及到类中的方法和属性的操作，可以理解为将静态方法寄存在该类的命名空间中。    静态方法是 类 中的方法，不需要被实例可以使用【类名.静态方法名()】的形式调用，同时也可以使用实例对象调用切记：静态方法没有self 和 cls这样的参数限制  静态方法 不能/用 调用 self  cls参数
'''# 方法调用 对象.方法 / 类.方法（对象）# 动态绑定属性与方法         直接绑定赋值
import copy# 面向对象三大特征
'''封装  提高代码安全性将数据（属性）和行为(方法)包装到类对象中。在方法内部对属性进行操作，在类对象的外部调用方法。这样，无需关心方法内部的具体实现细节，从而隔离了复杂度。在Python中没有专门的修饰符用于属性的私有，如果该属性不希望在类对象外部被访问，前边使用两个“_”。    self.__age=age  dir(stu) 查看属性   s._stu__age 可以这样获取继承  提高代码复用性多态  提高程序扩展性和可维护行'''# 继承    python 支持多继承
'''
class 类名 (父类1，父类2...):pass
如果一个类没有继承任何类，默认继承object
定义子类时，必须在其构造函数中调用父类的构造函数
'''class Person(object):def __init__(self, name, age):self.name = nameself.age = agedef info(self):print(self.name, self.age)class Student(Person):def __init__(self, name, age, stu_no):super().__init__(name, age)self.stu_no = stu_noclass A(object):passclass B(object):passclass C(A, B):pass# 方法重写
# 如果子类对继承自父类的某个属性或方法不满意，可以在子类中对其(方法体)进行重新编写
# 子类重写后的方法中可以通过super().xxx()调用父类中被重写的方法class Teacher(Person):def __init__(self, name, age, lengthofteaching):super().__init__(name, age)self.teacherOfYear = lengthofteachingdef info(self):super().info()print(self.teacherOfYear)teacher = Teacher('liSi', 30, 20)
teacher.info()# object类
'''object类是所有类的父类，因此所有类都有object类的属性和方法。内置函数dir()可以查看指定对象所有属性Object有一个__str__()方法，用于返回一个对于“对象的描述”，对应于内置函数str()经常用于print()方法，帮我们查看对象的信息，所以我们经常会对__str__()进行重写
'''# 多态
'''
简单地说，多态就是“具有多种形态"，它指的是:即便不知道一个变量所引用的对象到底是什么类型，仍然可以通过这个变量调用方法，在运行过程中根据变量所引用对象的类型,动态决定调用哪个对象中的方法。
'''# python 是一门 动态语言
'''
静态语言和动态语言关于多态的区别静态语言实现多态的三个必要条件（Java）继承方法重写父类引用指向子类对象
动态语言的多态崇尚“鸭子类型"当看到一只鸟走起来像鸭子、游泳起来像鸭子、收起来也像鸭子，那么这只鸟就可以被称为鸭子。在鸭子类型中，不需要关心对象是什么类型,到底是不是鸭子，只关心对象的行为
''''''
特殊属性        __dict__获得类对象或实例对象所绑定的所有属性和方法的字典__bases__   # 父类类型的元素__base__    # 类的基类__mro__     # 类的层次结构__subclasses__() # 子类的列表
特殊方法__len_()通过重写_len__()方法，让内置函数len()的参数可以是自定义类型__add__()通过重写_add__(方法，可使用自定义对象具有“+”功能__new__()用于创建对象__init__()对创建的对象进行初始化
'''# 类的赋值
'''变量 指向类的实例对象 由类指针 指向 类对象（模板）浅拷贝 与 深拷贝浅拷贝 Python拷贝一般都是浅拷贝，拷贝时，对象包含的子对象内容不拷贝，因此,源对象与拷贝对象会引用同一个子对象深拷贝 使用copy模块的deepcopy函数，递归拷贝对象中包含的子对象，源对象和拷贝对象所有的子对象也不相同
'''
# 输出id可发现不一样
# 浅拷贝
teacher2 = copy.copy(teacher)# 深拷贝
teacher3 = copy.deepcopy(teacher)

模块机制与包机制

# 模块机制与包机制# 模块    modules
'''
函数与模块的关系一个模块中可以包含N多个函数
在Python中一个扩展名为.py的文件就是一个模块
使用模块的好处方便其它程序和脚本的导入并使用避免函数名和变量名冲突提高代码的可维护性提高代码的可重用性
'''# 自定义模块
'''
创建模块新建一个.py文件，名称尽量不要与Python自带的标准模块名称相同
导入模块import 模块名称 as 别名from 模块名称 import 函数/变量/类
'''# 以主程序方式运行
'''
在每个模块的定义中都包括一个记录模块名称的变量__name__程序可以检查该变量，以确定他们在哪个模块中执行。
如果一个模块不是被导入到其它程序中执行，那么它可能在解释器的顶级模块中执行。顶级模块的_name_变量的值为_main_if _name_ = '__main__':pass
'''# 包机制
'''
Python中的包是一个分层次的目录结构，它将一组功能相近的模块组织在一个目录
作用:代码规范避免模块名称冲突
包与目录的区别包含__init__.py文件的目录称为包目录里通常不包含__init__.py文件
包的导入import 包名.模块名
'''# 内置模块
'''sys         与Python解释器及其环境操作相关的标准库time        提供与时间相关的各种函数的标准库OS          提供了访问操作系统服务功能的标准库calendar    提供与日期相关的各种函数的标准库ur1lib      用于读取来自网上(服务器)的数据标准库;json        用于使用JSON序列化和反序列化对象re          用于在字符串中执行正则表达式匹配和替换math        提供标准算术运算函数的标准库decimal     用于进行精确控制运算精度、有效数位和四舍五入操作的十进制运算logging     提供了灵活的记录事件、错误、警告和调试信息等目志信息的功能
'''# 第三方模块的安装  pip install 模块名
# 使用            import 模块名

IO 文件读写

# 文件读写# 编码格式  py默认utf-8   如何改 首行 #encoding=GBK
# 常见的字符编码格式 ASCII　》　ISO8859-1 》 （GB2312》GBk》GB18030） / UTF-8 《  Unicode
# python解释器 内存unicode       外存.py文件，utf-8# 文件读写原理    俗称 IO操作 input/output    采用队列，一种数据结构
# 内置函数open() 创建文件对象，通过IO流将磁盘文件的内容和程序中的对象中的内容进行同步
# 语法，file = open(filename【，mode,encoding】)
# 被创建的对象名 = open（文件名【，打开模式：默认只读，默认文本中中文字符编码格式：gbk】）file = open('a.txt', 'r')
print(file.readlines())
file.close()# 常用文件打开模式
# r=read    w=write     a = 写入追加        b以二进制读取，常与r和w一起用    +以读写方式展开，常与其他模式一起用，如： a+
file = open('a.txt', 'w')
file.write('python')
file.close()file = open('a.txt', 'a')
file.write('python')
file.close()file = open('a.txt', 'rb')
print(file.readlines())
file.close()'''
示例代码
src_file=open ('logo. png','rb')
target_file=open (' copylogo. png','wb')
target_file.write (src_file.read())
target_file.close()
src_file.close()
'''# 文件对象的常用方法
'''
read([size])                从文件中读取size个字节或字符的内容返回。若省略[size]，则读取到文件末尾，即一次读取文件所有内容
readLine()                  从文本文件中读取一行内容
readLines()                 把文本文件中每一行都作为独立的字符串对象，并将这些对象放入列表返回
write(str)                  将字符串str内容写入文件
writelines(s_list)          将字符串列表s_list写入文本文件，不添加换行符
seek(offset[,whence])       把文件指针移动到新的位置，offset表示相对于whence的位置:offset:为正往结束方向移动，为负往开始方向移动whence不同的值代表不同含义:0:从文件头开始计算（默认值)1:从当前位置开始计算2:从文件尾开始计算
tell()              返回文件指针的当前位置
flush()             把缓冲区的内容写入文件，但不关闭文件
close()             把缓冲区的内容写入文件，同时关闭文件，释放文件对象相关资源
'''# with语句（上下文管理器）    with语句可以自动管理上下文资源,不论什么原因跳出with块,都能确保文件正确的关闭，以此来达到释放资源的目的
# with open() as src_file:
#    pass（src_file.read()）# with open('logo.png', 'rb') as src_file:
#     with open('cpoy2logo.png', 'wb') as target_file:
#         target_file.write(src_file.read())

OS模块

# os模块
'''
os模块是Python内置的与操作系统功能和文件系统相关的模块,该模块中的语句的执行结果通常与操作系统有关,在不同的操作系统上运行，得到的结果可能不一样。
os模块与os.path模块用于对目录或文件进行操作
'''# import os
# os.system('calc.exe')
# os.startfile('磁盘路径.app.exe') 记得转义字符 \\'''
getcwd()                            返回当前的工作目录
listdir(path)                       返回指定路径下的文件和目录信息
mkdir(path[, mode])                 创建目录
makedirs(path1/path2.. . [, mode])  创建多级目录
rmdir(path)                         删除目录
removedirs(path1/path2.. .. . .)    删除多级目录
chdir(path)                         将path设置为当前工作目录
'''# os.path模块操作目录相关函数
'''
import os.pathabspath(path)       用于获取文件或目录的绝对路径
exists(path)        用于判断文件或目录是否存在，如果存在返回True, 否则返回False
join(path, name)    将目录与目录或者文件名拼接起来
split()             分类路径和文件
splitext()          分离文件名和扩展名
basename(path)      从一个目录中提取文件名
dirname(path)       从一个路径中提取文件路径，不包括文件名
isdir(path)         用于判断是否为路径
endwith('str')
'''# demo1 从目录下 获取某指定类型文件
'''
import os
path = os.getcwd()
lst = os.listdir(path)
for filename in lst:if filename.endwith('.py'):print(filename)
'''# demo2 获取目录下所有文件名，包括子目录内的文件也打印
'''
import os
path = os.getcwd()
lst = os.listdir(path)
for dirpath,dirname,filename in lst:for dir in dirname:print(os.path.join(dirpath,dir))for file in dirname:print(os.path.join(dirpath,file))
'''