Python学习笔记

Python学习笔记

Python学习笔记

入门代码基本数据类型

整型浮点型字符串列表元组集合字典布尔其他 运算符流程控制

顺序结构选择结构

ifif-elseif-elif-else三目运算符 循环结构

forfor-elsewhilewhile-else 推导式

列表推导式集合推导式字典推导式元组推导式（生成器） 函数

函数参数

必选参数位置参数关键字参数默认参数*/ 变量作用域匿名函数 压包、解包

可迭代对象都可以解包解包合并可迭代对象解包传递参数 闭包、装饰器

闭包装饰器

原理不带参数的装饰器带参数的装饰器 面向对象文件、IO

文件

文件方法文件读取文件写入 IO

入门代码

abc = input('请输入hello world!n>')
if abc == 'hello world!':
    print('恭喜，小伙子你已经入门了！准备好了吗？接下来的修炼要慢慢领悟哦！')
else:
    print('小伙你好像不太适合学python。。。')

基本数据类型

基本数据类型：int（整型）,float（浮点型）,str（字符串）,list（列表）,tuple（元组）,set（集合）,dict（字典）,bool（布尔）

可变序列：列表，集合，字典
不可变序列：字符串，元组
可迭代类型：字符串，列表，元组，集合，字典

整型 浮点型 字符串 列表 元组 集合 字典 布尔 其他 运算符 流程控制 顺序结构

a = 1
b = 2
c = 3

print(a)
print(b)
print(c)

选择结构 if

n = 100
if n >= 10:
    print('n 大于等于 10')
if n >= 100:
    print('n 大于等于 100')
if n >= 1000:
    print('n 大于等于 1000')

if-else

n = 1
if n > 100:
    print('n 大于 100')
else:
    print('n 小于等于 100')

if-elif-else

n = 100
if n >= 10:
    print('n 大于等于 10')
elif n >= 100:
    print('n 大于等于 100')
elif n >= 1000:
    print('n 大于等于 1000')
else:
    print('n 小于 10')

三目运算符

# if-else判断奇数偶数
n = 100
what_number = '偶数' if not n % 2 else '奇数'
print(what_number)

# and-or实现判断奇数偶数
n = 100
what_number = n % 2 == 0 and '偶数'or '奇数'
print(what_number)

循环结构 for

# 计算1加到100的和
n = 0
for i in range(101):
    n += i
    
print(n)

for-else

# 计算1加到100的和
n = 0
for i in range(101):
    n += i
    # break
else:
    print('no break,I will execute!')

print(n)

while

# 计算1加到100的和
i,n = 0,0
while i <= 100:
    n += i
    i += 1

print(n)

while-else

# 计算1加到100的和
i,n = 0,0
while i <= 100:
    n += i
    i += 1
    # break
else:
    print('no break,I will execute!')

print(n)

推导式 列表推导式

# 九九乘法表
list_derivation = ['%dx%d=%d'%(j,i,i*j) for i in range(1,10) for j in range(1,i+1)]

集合推导式

# 生成100以内的偶数集合
set_derivation = {i for i in range(100) if i%2==0}

字典推导式

# 生成128以内的ascii码
dict_derivation = {chr(i):i for i in range(128)}

元组推导式（生成器）

# 构造生成100000000以内数的生成器
generator = (i for i in range(100000000))

函数 函数参数 必选参数

def f(a,b,c):
    print(a,b,c)

f(1,2,3)

位置参数

def f(*args):
    print(*args)
    print(args)

f(1,2,3)
f(*[1,2,3])

关键字参数

def f(**kwargs):
    # print(**kwargs) # error
    print(kwargs)

f(a=1,b=2,c=3)
f(**{'a':1,'b':2,'c':3})

默认参数

def f(a=1,b=2,c=None):
    print(a,b,c)

f()
f(c=3)

*

# 声明关键字方式传参
def f(a,b,*,c,d=2,e):
    print(a,b,c,d,e)

f(1,2,c=3,d=4,e=5)

*号之后只能使用关键字参数 /

# 声明非关键字方式传参
def f(a,/,b,c):
    print(a,b,c)

f(1,b=2,c=3)

/号之前只能使用位置参数 变量作用域

x = 0
def outer():
    a = 0
    def inner1():
        nonlocal a
        a = 1
        print(a)

    def inner2():
        global a,x
        x = 123
        a = 2
        print(a)

    inner1()
    print(a)

    inner2()
    print(a)

outer()
print(x)
print(a,id(a))
print(globals(),id(globals()['a']))

global：块内声明参数为全局参数，使其可以在被声明的块内被修改。nonlocal：声明参数为外层参数，使其可以被内层代码修改。 匿名函数

square = lambda x:x**2
print(square(10))

压包、解包 可迭代对象都可以解包

# 字符串
a,b,c = 'abc'

# 列表
a,b,c = ['a','b','c']

# 元组
a,b,c = (1,2,3)

# 集合
a,b,c = {1,2,3}

# 字典
a,b,c = {'a':1,'b':2,'c':3}

# 其他可迭代对象
a,b,c = (i for i in range(1,4))
a,b,c = {'a':1,'b':2,'c':3}.items()
a,b,c = enumerate(['a','b','c'])
a,b,c = reversed(['c','b','a'])
...

解包合并可迭代对象

# *解包
a = [1,2,3]
b = [*a,4,5,6]

# **解包
a = {'a':1,'b':2,'c':3}
b = {**a,'d':4,'e':5,'f':6}

解包传递参数

# *解包
def f1(a,b,c):
    print(a,b,c)

f1(*[1,2,3])

# **解包
def f2(b,a,c):
    print(a,b,c)

f2(**{'a':1,'b':2,'c':3})

# 传递参数时解包，接收参数时压包
def f3(*args,**kwargs):
    print(args,kwargs)

f3(*[1,2,3],**{'a':1,'b':2,'c':3})

f(*[1,2,3])等价于f(1,2,3)f(**{'a':1,'b':2,'c':3})等价于f(a=1,b=2,c=3)压包获取的数据args是元组，kwargs是字典压包可以看做作是将多个参数存到元组或字典中，解包则是将元组或字典中的数据拿出来。 闭包、装饰器 闭包

def outer(func_name):
    print('outer开始执行了')

    def inner1():
        print('inner1执行了')

    def inner2():
        print('inner2执行了')

    print('outer执行完成了')
    if func_name == 'inner1':
        return inner1
    else:
        return inner2

outer('inner2')()

装饰器 原理

def hello():
    print('123')
    
def decorator(f):
    return f()
    
hello = decorator(hello)
# 等价于下面语法糖写法
@decorator
def hello():
    print('123')

不带参数的装饰器

# 不带参数的装饰器
def outer(f):
    def inner(*args, **kwargs): # 回调函数参数声明
        print(args,kwargs)
        param = "I'm the param of f function."
        f(param)
    return inner

# 闭包写法
# def f(param): # 原函数参数声明
#     print(param)
#     print('hello')
#
# f = outer(f)(1,2,3,4,5,whoami="I'm the param of callback function.")

# 语法糖写法
@outer
def f(param): # 原函数参数声明
    print(param)
    print('hello')

f(1,2,3,4,5,whoami="I'm the param of callback function.")

带参数的装饰器

装饰器函数，包装函数带参数

# 带参数的装饰器
def outer(decorator_param=None): # 装饰器函数参数声明
    def wrapper(f):
        def inner(*args, **kwargs): # 包装函数参数声明
            print(decorator_param)
            print(args,kwargs)
            param = "I'm the param of f function."
            f(param)
        return inner
    return wrapper

# 闭包写法
# def f(param): # 原函数参数声明
#     print(param)
#     print('hello')
#
# f = outer('a')(f)(1,2,3,4,5)

# 语法糖写法 
@outer(decorator_param="I'm the param of decorator.")
def f(param): # 原函数参数声明
    print(param)
    print('hello')

f(1,2,3,4,5,whoami="I'm the param of callback function.")

装饰器函数带参数，包装函数不带参数

def outer(decorator_param=None):
    def inner(f):
        print(decorator_param)
        return f
    return inner

# 闭包写法
# def index():
#     print('hello')
# 
# index = outer('/index')(index)

# 语法糖写法
@outer('/index')
def index():
    print('hello')

面向对象 文件、IO 文件 文件方法

fp = open(地址,模式) 打开文件
fp.close() 关闭文件
with open() as f1,open() as f2: 上下文管理(可以自动关闭文件)
fp.seek(m) 移动文件指针 当前位置向后移动m个字节
fp.tell()  查看文件指针
fp.flush() 刷新缓冲区和fp.close()类似

文件读取

fp.read(m)    文件读取 读取m个字节
fp.readline() 按行文件读取
fp.readlins() 列表形式读取文件

文件写入

fp.write(内容)       文件中写入内容
fp.writelines(list) 文件中写入列表类型内容
fp.truncate()       文件内容清空

IO

import io

# 定义字符串缓冲区
a = io.StringIO()
# 字符串缓冲区写入
a.write('123')
a.writelines(['a','b','c'])
# 字符串缓冲区读取
print(a.getvalue())

# 定义字节缓冲区
b = io.BytesIO()
# 字节缓冲区写入
b.write(b'123')
b.writelines([b'a',b'b',b'c'])
# 字节缓冲区读取
print(b.getvalue())