#! /usr/bin/env python
# -*- coding: utf-8 -*-
# 注释
换行写代码 \
进制
十进制 123456789
二进制 0b123
八进制 0o123
十六进制 0x123
变量不用声明必须赋值
字符串 ' ' " " """ """ ''' ''' 用来括长字符串，保留换行格式
转义字符 \
\uxxxx 表示使用Unicode编码 # eg: "\u0040"
格式化字符串
在Python中很少用“+”进行字符串拼接，字符串只能和字符串拼接
print('a=',a)
创建字符串时指定占位符
b = 'sdasdasd%s'%'孙悟空'
b= 'dsadad%s%s'%('sdsad','sdad')
b = 'sdasdasd%3s'%'孙悟空' 最小填充3，不够前边补位空格
b = 'sdasdasd%3.5s'%'孙悟空' 最小填充3最长5，不够前边补位空格超出后边截尾
b = 'sdasdasd%s'%123
b = 'sdasdasd%.1f'%123.5
b = 'sdasdasd%d'%123
b = r'sadsad' #字符串前加r表示，启用原始字符串模式，转义字符串等失效
%s%f%d
格式化字符串
c=f"hello {a} {b}"
print('a=',+a)
print('a=',a)
print('a=%s'%a)
print(f'a={a}')
print("adas",end="")
a="小米" * 20 #字符串乘以数字，字符串复制
boolean值 True False
bool python简写
None 空值
类型检查
c=type(变量) #用来检查值的类型
对象 id #内存地址 id()
type #类型 功能 type()
value #值
a 可变对象
123 不可变对象
int()
float()
bool() # '' 0 None
str()
算术运算符 +-*/ // #整除 ** 幂运算 %
赋值运算符
关系运算符 < > <= >= == != is is not #比较两个对象是否为同一对象
逻辑运算符 not and or
非布尔值进行逻辑运算时，Python会将其当成boolean值运算，返回原值
逻辑运算符可以连号 result = 1 < 2 < 3
条件运算符
语句1 if 条件表达式 else 语句2
max = a if a > b else b
流程控制
条件判断语句（if）
语法 ： if 条件表达式 : 语句
代码块缩进管理多行
input(['参数'])
语法： if 条件表达式 :
代码块
else :
代码块
语法： if 条件表达式 :
代码块
elif 条件表达式 :
代码块
elif 条件表达式 :
代码块
elif 条件表达式 :
代码块
else :
代码块
循环语句
while
语法：
while 条件表达式 ：
代码块
while 条件表达式 ：
代码块
else :
代码块
break
continue
pass #占位
模块引入
from time import *
time()
序列
列表 list [ ]
python列表可以存放任意数据
以下为通用操作对字符串有效
len(s)
index可以是负数，倒数 eg：-1 倒数第一个
切片获取 list[start:end] #包括起始位置，不包括结束位置
起始位置和结束位置都可以省略
list[:]
list[start:end:步长] #步长不能是0，可以是负数，负数为逆序
list + 列表拼接 * 复制
in not in 检查是否存在
print('dd' in list) # True False
min(list) #获取最小值
max(list) #获取最大值
s.index()
s.count(s[0]) #统计指定元素出现的次数
序列——————有序
可变序列
list
不可变序列
str
tuple #元组
可变序列可修改
索引修改
del s[2] # 删除
切片 s[:] ##从头到尾切片，获得副本
切片替换 s[0:2] = ['s','w','w'] #可以多个替换一个
s[0:0] = 'd' # 索引0位置插入
s[::2] = ['s','s'] #设置步长时，赋值双方list 数量一致
del s[::2] #切片删除
s[0:2]=[] #赋值空来删除
不可变序列
s=list(s) #强制转换
可变序列方法
s.append(str) #添加元素
s.insert(i,x) #插入元素（非替换）
s.extend() #使用新序列扩展当前序列 【添加有个序列】
s.clear() #清空序列
s.pop(index) #根据索引删除返回被删除对象
s.pop() #删除最后一个
s.remove(x) #删除指定值，【删除第一个】
s.reverse() #反转
s.sort() #排序
s.sort(reverse = True) #排序
s.copy() s[:] ##制作副本的两种方法
列表遍历
for 变量 in 序列 :
代码块
range([start],end,[step]) #生成自然数的序列的函数
r = range(5) #[0,1,2,3.4]
list(r)
!!!! python 里的for循环
for i in range([start],end,[step]) :
代码块
else
break;/continue
tuple 元组 ()
创建
my_tuple = ()
my_tuple = 1,2,3,4 #元组不为空括号可以省略
my_tuple = 1,
#元组的解包（解构）
a,b,c,d = my_tuple
a,b = b,a #变量交换
a,b,*c = my_tuple # *c获得剩余元素，像指针
##也可以对列表和str解包
可变对象
== != #比较值 is is not #比较对象
字典 dict
item项
key-value
创建
d = { }
语法：
d = { key:value,key:value }
d = dict(key=value,key=value) #dict 函数
双值子序列
[1,2] (1,2) #双值
[(1,2),(3,5)] #子序列
d = dict( [(1,2),(3,5)])
len(变量)
in
not in
'hello' in d #查看键是否存在
d[key] # key必须加引号
d['key'] = value #没有的可以添加，不能读取
setdefault(key[,default]) #添加字段，设置默认值
result = setdefault(key[,default]) # result 返回实际值
update([other])
eg:
d1={'a':1,'b':2}
d2 = {'c':3,'d':4}
d1.update(d2)
d1 = {'a':1,'b':2,'c':3,'d':4} #重复key会被d2替换
del d[key] #删除
####方法
popitem() #随机删除一个item元素（一般删除最后一个）返回两个元素的元组，被删除的那个
pop(key[,default]) #删除指定的，返回删除的值
#写上默认值没有不报错，返回默认值
clear() #清空
copy() #对字典进行浅复制 只复制值，不会进行智能级联复制
遍历字典：方法
keys() :
for k in d.keys() :
d[k]
values() :
for v in d.values() :
v
items() :
for k.v in d.items() :
k v
集合（set） { }
存储不可变对象 无序 不重复
s = {1,2,34,4}
s = set() #空集合
s = { } #空字典
s = set(序列或者字典) #转换为集合
s = set(字典) #保留的集合体是键
in not in
'a' in s
len(s)
add() #集合中添加
s.add(10)
update() #讲一个集合中的所有元素添加到集合中
s.update(s2) #s2可以是集合，序列，字典
pop()随机删除一个集合中的元素,并返回这个元素
s.pop()
result = s.pop()
remove() #删除指定元素
s.remove(100)
clear() #清空
s.clear()
copy() #对集合进行浅复制
集合运算
s1={1,2,3,4,5}
s2={3,4,5,6,7}
& #交集
s3 = s1 & s2
| #并集
s3 = s1 | s2
- #差集
s3 = s1 - s2 # s3 = {`,2}
^ #异或集
s3 = s1 ^ s2 # s3 = {1,2,6,7}
<= #检查一个集合是否为另一个集合的子集
a <= b # true a是b的子集，b是a的超集
< #检查一个集合是否为另一个集合的真子集
a<b
>= > #检查一个集合是否为另一个集合的超集
函数（function）
def 函数名（[形参1，形参2，....形参n]）:
代码块
调用函数 fn()
##函数的参数
在定义函数使，可以定义数量不等的形参，用‘，’隔开
def fn2(a,b):
a+b
def fn3(a,b=2) : # b=2 为默认值不传参数不报错，默认值生效
代码块
##调用时**
##位置参数一一对应
fn2(1,2)
##关键字参数
fn2(b=1,a=2)
##位置参数和关键字参数可以混合使用，，位置参数必须在关键字参数的前边
eg:
print('hello',end=' ') #防止换行
实参类型可以为任意类型 ##Python 不检查，所以Python函数中需要检查参数类型
在定义函数时，可以在形参前加一个* ，这样这个形参会获取所有实参，并保存为元组，“参数装包”
##不定长参数只能有一个，但可以配合其他参数
def fn(*a):
sum=0
for n in a :
sum+=n
print(sum)
def fn(a,b,*c):
所有带* 的参数后的参数必须以关键字参数传递
def fn(a,b,*c，d,e):
fn(1,2,3,4,5,d=6,e=7)
def fn(*,a,b):
##表明该函数必须以关键字参数传递
!!## *形参必须以位置参数传递，不能接收关键字参数
## “**” 形参可以接收其他关键字参数，他会将这些参数保存到一个字典中，字典的key为参数名，value为参数值
## **形参只能有一个，并只能放在所有形参最后
实参
参数解包（拆包） * 序列解包
#fn(1,2,3)
# t=(1,2,3) #序列都可以，元组或列表
fn(*t)
传递参数时也可以在序列的参数前添加星号，这样他会自动将序列中的元素依次作为参数传递
字典实参解包,用**解包
d={a:1,b:2,c:3}
fn(**d)
返回值
return :
return #100 or 变量
return None
return 结束函数
文档字符串(doc str)
help() #Python的内置函数，可以查询Python中函数用法
hellp(函数对象) #hellp(print)
--函数内部编写函数说明
--文档字符串，直接写在函数第一行的字符串
def fn(a:int,b:bool,c:str='hello') ->str : # 参数后冒号只是描述作用，也能看成文档字符串的一种;= 表示默认值 ； ->表示返回值
'''
doc str
'''
代码块
作用域（scope），命名空间(namespace)#变量存储位置
每一个作用域都有一个自己的命名空间
命名空间实际上就是一个字典，是一个专门用来存储变量的字典
locals() #用来获取当前作用域的命名空间
#如果在全局作用域中调用locals()获取全局命名空间
dict = locals()
scope = locals() #当前命名空间
scope['c'] = 1000 #向字典中添加key-value 相当于在全局变量中创建了一个变量
globals() #此函数可以在任意位置获得全局命名空间
scope = globals() #全局命名空间
、
递归 1.基线条件问题分解的最小条件，此时不再递归，直接返回
2.递归条件 将问题继续分解的条件
#基线条件，判断n==1 不再循环
10！=10*9！
9！=9*8！
......
2！=2*1！
1！=1
def fn(n) :
#基线条件
if(n==1):
return 1
#递归条件
return n*fn(n-1)
def hui_wen(s):
#基线条件
if len(s) < 2 :
return True
elif s[0] != s[-1] :
return False
return hui_wen(s[1:-1])
Python中函数是一等对象
函数式编程
高阶函数：接收一个或多个函数，将函数作为返回值返回
普通函数改变的返回值，得到返回值不影响原对象
【高阶函数1：参数是函数】
def fn(fnc,lst):
new_ls = []
for n in lst :
if fnc(n) :
snew_ls.append(n)
return new_ls
内置函数
filter(function,iterable) #参数：1方法；2可迭代
#过滤器
#参数
# 1.函数，根据此函数过滤 。True 为通过元素，通过过滤
# 2.需要过滤的序列（可迭代）
#返回值
# 过滤后的新序列（可迭代）
匿名函数 lambda函数表达式(语法糖)
#语法
lambda 参数列表 : 返回值
实例
1. def fn(a,b):
return a+b
2. lambda a,b : a+b
调用
(lambda a,b : a+b)(10,20)
3. fn = lambda a,b : a+b
调用
fn(10,20)
map()
map()函数可以对可跌倒对象中的所以元素做指定操作，然后将其添加到一个对象中返回
l = [1,2,3,4,5,6,7]
r = map(lambda i : i+1 , l) #i 为l中的元素
sort() #列表的方法
#该方法用来对列表中的元素进行排序，影响原对象
#sort()方法默认是直接比较列表中的元素的大小
#在sort()可以接收一个关键字参数，key
# key需要一个函数作为参数，当设置了函数作为参数
# 每次都会以列表中的一个元素作为参数来调用函数，并且使用函数返回值来比较元素大小
list.sort()
#是用“<”进行比较的
list.sort(key=len)
sorted() #与sort()使用方法一样
#对任意序列都可以排序，返回新对象
【高阶函数2】
返回值是函数
#闭包
def fn():
#函数内部定义一个函数
def inner():
print('晚上好')
return inner
fn()()
通过闭包可以创建只有当前函数可以访问的变量
# sum(list)/len(list) 求平均值
def make_averager():
#创建一个列表，用来保存数值
nums= [ ]
#创建一个函数，用来计算平均值
def averager(n) :
#将n添加到列表中 #nums=[] 不能放这里是因为重新new了，会为空
nums.append(n)
#求平均值
return sum(nums)/len(nums)
return averager
#闭包的形成->数据安全，隐藏外部变量
1.有函数嵌套
2.将内部函数作为返回值返回
3.内部函数必须要使用到外部函数的变量
装饰器
#OCP原则 开放对程序扩展，要关闭对程序的修改
###? 运用了闭包
-----------------------------------------------------------------------
def fn(old):
...
用来对其他函数进行扩展
...
def new_fn(*args , **kwargs): #对位置参数和关键字参数进行装包
xxxxxx #扩展代码
result = old(*args , **kwargs) #对位置参数和关键字参数进行解包
xxxxxx #扩展代码
return resukt
#返回新函数
return new_function
----------------------------------------------------------------------
调用
f= fn(fn1)
r=fn(fn2)
真实场景:
创建装饰器函数begin_end
使用
@begin_end #注解方式添加装饰器
def say_helllo():
print('大家好')
调用
say_hello()
#可以多个装饰同时使用
@begin_end #注解方式添加装饰器
@fn
def say_helllo():
print('大家好')
say_hello() #内装饰器先起作用，fn先起作用
面向过程，符合人类思想；函数式编程，复用性提高；面向对象，对象自己自己完成
##类class
#类的定义
构成：1数据（属性【一般保存到实例中】）2行为（方法【一般保存到类中】）
#语法 class 类名([父类])：
代码块
公共的属性。。
#对象初始方法
def __init__(self,....):
...
#其他方法
def method_1(self,....):
....
def method_2(self,....):
....
.........
class MyClass():
name='' #公共属性 相当于java中static类型，只有实例没有时，默认查找
def fn(self): #公共函数，类中的函数必须有一个形参
print(1) #函数无法访问类中的变量
print(MyClass)
#类方法（在类内部使用@classmethod来修饰的方法属于类方法）
@classmethod
class MyClass():
name='' #公共属性 相当于java中static类型，只有实例没有时，默认查找
@classmethod
def fn(cls): #类方法，也必须有一个形参cls,cls代表类对象
print(1) #函数无法访问类中的变量
print(MyClass)
#创建对象
mc = MyClass() #创建对象不像java一样需要new
# isinstance(object,Class) 函数检查一个对象是否为一个类 的实例
对象.属性= 值；
mc.myFunction() #调用类中方法时自动传一个参数(对象本身,和java中的this有点像)
#方法每次调用时第一个参数，默认为self
#类中可以创建一些特殊方法（魔术方法）
#特殊方法以__开头，以__结尾
#特殊方法不需要 我们自己调用,会自动调用
class Person :
def __init__(self):
print('a')
pass
def say_hello(self):
pass
p1=Person()
p1.say_hello()
对象创建流程
自上而下执行代码，先执行类中代码块
1创建一个变量
2在内存中创建一个对象
3_init_(self)方法执行
4将对象id赋值给变量
#可以为class中对象的属性定义时使用双下划线，__xxxx
#双下划线开头的属性，是对象的隐藏属性，隐藏属性只能类内部访问，不能通过对象访问（!=java中的private） __属性名 -> _类名_属性名
一般类中的私有属性用“下划线”+属性
get set 方法属性话
添加"属性"装饰器
get方法装饰器方法上边添加
@property
set方法装饰器
@属性名.setter
_# get方法先设计，才能设计setter方法
继承
Class 类名（[父类]）:
pass
isinstance(d,Object) #判断d是否为object的实例
issubclass(a,b) #判断a是否为b的子类
#类名.__bases__ 获得当前类的父类
##Python是多继承的（java是单继承的）
类名(父类,父类):
pass
#多个父类中有同名方法，先在第一个父类中找
多态
len()是因为对象中有特殊方法__len__()
类的属性和方法
#静态方法
@staticmethod
def fn():
pass #类中静态方法无参数
垃圾回收
自动垃圾回收机制（和java挺像的嘛，哈哈）
#del是一个特殊方法，他会在对象被垃圾回收前自动调用,回收的是类对象
def __del__(self):
pass
#特殊方法，魔术方法
双下划线开头结尾
一般不需要我们手动调用，一般在特殊情况下自动调用
__str__() ：对象被打印时调用
__repr__() :在对对象使用repr（）函数时调用，是在交互模式下自动调用，即在命令窗口a回车，输出a的值时调用
object.__lt__(self, other) <
object.__le__(self, other) <=
object.__eq__(self, other) =
object.__ne__(self, other) !=
object.__gt__(self, other) >
object.__ge__(self, other) >=
#判断大小
__len__() #获得长度
__bool__() #boolean 装换规则
object.__add__(self, other)
object.__sub__(self, other)
object.__mul__(self, other)
object.__matmul__(self, other)
object.__truediv__(self, other)
object.__floordiv__(self, other)
object.__mod__(self, other)
object.__divmod__(self, other)
object.__pow__(self, other[, modulo])
object.__lshift__(self, other)
object.__rshift__(self, other)
object.__and__(self, other)
object.__xor__(self, other)
object.__or__(self, other)
.....................
#运算特殊方法
模块化
#一个Python文件就是一个模块
#在一个模块中引入外部模块
1.import 模块名（Python文件名，不带后缀）
module为单实例
2..import 模块名 as 模块别名
import 可以在程序的任意位置调用，一般在开头
每个模块内部都有一个__name__属性。通个这个属性可以获得模块的名字
__name__为__main__的是主模块
#调用
模块名.变量名
3.只引入模块的部分内容
#语法
from 模块名 import 变量，变量，....
from 模块名 import 变量 as 变量别名
#调用
变量名
from 模块名 import *
#### 模块中 _变量 是隐藏变量，用from 模块名 import *不起作用
#测试代码
#只有单前代码为主模块时执行
if __name__ == '__main__' :
pass
包 package
import 包名
#包中必须有一个__init__.py 文件，其中有包中的主要文件
from 包名 import 文件名/模块名
#__pycache__是模块缓存文件
#py代码在执行时会转换为机器码，所以我们在使用模块时，也需要将模块代码转换为机器码，Python在编译一次后会放入缓存文件中
Python标准库
核心思想：开箱
sys模块，Python系统参数变量，操作解析器
import sys
1.sys..argv 获得解释器参数列表
print（sys..argv）
2.sys.modules 获得当前进程引入的所有模块（字典）
print（sys..modules ）
#key 模块名，value 模块实例对象
3.sys.path 模块搜索路径的列表，即调用模块的搜索顺序
4.sys.platform 当前Python运行平台即系统环境
5.sys.exit([str提示]) 函数用来退出程序
pprint 模块 提供了pprint（）方法，该方法可以对打印的数据做简单的格式化
pprint .pprint (数据)
os 模块，对操作系统进行访问
import os
1.os.environ 通过这个属性可以获得系统的环境变量
pprint .pprint (os.environ['path'])
2.os.system([str命令]) #执行系统自身的命令
3.listdir()
import os
from pprint import pprint
#os.listdir([path=''])获取指定的目录的目录列表（默认为当前目录'.'）
r=os.listdir()
pprint(r)
4.os.getcwd()#获得当前所在目录
5.os.chdir([path])#切换目录
6.os.mkdir(path)#创建目录
7.os.rmdir(path)#删除目录
8.open('aa.txt','w')#创建文件
9.os.remove('aa.txt')#删除文件
10.os.rename('旧名字','新名字')#重命名或剪贴
os.rename('旧名字','新路径名字')
##异常
try语句
try:
代码块(可能错误代码)
except:
代码块（处理方式）
else:
代码块（没错误时执行代码，错误不执行）
异常的传播---抛出异常
产生异常时，实际上是创建了一个异常对象
try语句
try:
代码块(可能错误代码)
except NameError:
#如果except后边不跟内容，捕获所有异常
#如果except后边跟一个异常类型，捕获此类异常
代码块（处理方式）
except IndexError:
代码块
except [Exception]:
代码块
else:
代码块（没错误时执行代码，错误不执行）
try:
代码块(可能错误代码)
except Exception as e :
代码块（处理方式）
else:
代码块（没错误时执行代码，错误不执行）
finally :
代码块
try必须有，except 和 finally必须有一个
#抛出异常
raise
raise 语句后需要跟一个异常类或者异常的实例
if(a<0):
raise Exception('a为负数') #强行抛出异常
自定义异常类，创建类继承Exception
class MyException(Exception):
pass
文件(File)
1.打开文件
open()
open(file, mode='r', buffering=-1, encoding=None, errors=None, newline=None, closefd=True, opener=None)
默认是以文本模式打开(文本模式，二进制模式)
文本文件： encoding='utf-8'
操作模式：mode='r' # mode='w' 时，没有文件会创建，存在会截断； # mode='a' 追加内容，没有文件会创建，存在会追加内容 ；# + 追加操作，mode='r+',即可读又可写，mode='w+',即可写又可读，mode='a+',即可追加又可读； mode='x' 新建文件，如果文件存在报错，不存在创建，并可写入（可避免覆盖已有的）；t 默认情况下，文本文件；b 二进制文件，mode='rb';
参数：file文件路径
file_object = open(路径) #返回文件对象
2.操作
content = file_object.read() #读取所有内容
@1 读取
#help(file_object.read)
#file_object.read(-1)
#file_object.read(count) #读取指定数量的内容, i<count,读取剩余，没有了I= 0，返回‘’空串
try:
with open(file_name,encoding='utf-8') as file_object :
file_count=''
chunk = 100
while True:
content = file_object.read(chunk ) #读取所有内容
print(content,end='' )
if not content :
break
file_count +=content
except FileNotFoundError:
代码块（处理方式）
# readline() 读一行
# readlines() 以列表形式保存
try:
with open(file_name,encoding='utf-8') as file_object :
for file_count in file_object :
print(file_count )
file_count +=file_count
except FileNotFoundError:
代码块（处理方式）
@2 写 write()
with open(file_name,mode='w',encoding='utf-8') as file_object :
# open(file_name,'w',encoding='utf-8')
#指定操作类型w
#write文本型直接write(str)
file_object.write('hello')
file_object.write('hello\n')
r=file_object.write(str(123)) #可以分段写入，只能写入字符串,每次写入会返回写入的长度
#旧文件
file_name=''
with open(file_name,mode='rb') as file_object :
#二进制不要encoding
#新文件
new_name = '';
with open(file_name,mode='wb') as new_object :
#每次读取大小
chunk = 1024*100
while True :
#从旧文件读取
content = file_object.read(chunk)
#内容读取完毕终止
if not content :
break
#将读取到的写入新文件
new_object.write(content )
@3 读取位置
tell()查看当前读取位置
seek() 修改当前读取位置
#seek()需要两个参数，1要切换的位置；2计算位置方式（0,1,2）
#0表示从头计算（默认值）；1表示从当前已读位置计算；2表示从最后位置接着读，用-1倒数
with open(file_name,mode='rb') as file_object :
print(file_object.read(100),end='' )
print('当前读取到了',file_object.tell())
file_object.seek(55,0)
3.保存
4.关闭
file_object.close()
#with ... as 语句
with open(file_name) as file_object :
#file_object 存活时间只是在with 。。。 as 的代码块中，等于自动关闭
print(file_object .read())
#
try:
with open(file_name) as file_object :
print(file_object .read())
except FileNotFoundError:
代码块（处理方式）
else:
代码块（没错误时执行代码，错误不执行）
文件的其他操作
os
5694
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
