Python基础（二）

1.变量作用域

1.全局/局部变量

全局变量：在函数外部定义的变量

局部变量：在函数内部定义的变量

2.作用域

局部作用域 local

闭包函数外的函数中 enclosing

全局作用域 global

内置作用域 built-in

查询规则：L --> E --> G --> B

3.改变作用域

需要改变G中的变量，通过global

需要改变E中的变量，通过nonlocal

2.闭包函数

1.定义

函数A里面定义了一个新的函数B

函数B使用函数A的变量

满足以上两个条件，函数B就是一个闭包函数

2.使用方式

直接调用

返回函数名

3.作用

优：数据持久化

缺：浪费内存

4.注意事项

闭包函数不能直接修改外部函数的变量

3.内置函数

1.类型相关的

int(),float(),bool(),complex(),str(),list(),tuple(),set(),dict()

2.变量相关的

id() type() print() locals()

3.数学相关的

abs() sum() max() min()

pow() round() range()

4.进制相关的

hex() oct() bin() chr()

ord() repr() eval()

4.字符串方法

对象.方法名()

方法就是函数
对象：一切皆对象

.upper() 全部转为大写
.lower() 全部转为小写
.capitalize() 首字母大写
.title() 每个单词的首字母大写
.isalnum() 只能有数字，字母，中文
.isalpha() 只能有字母，中文
.isdigit() 只能有数字
.isupper() 检测是否为大写
.islower() 检测是否为小写

5.格式化函数

1.基础用法

a = ‘{},{},{}高高兴兴牵着手’

print(a)
print(a.format(‘熊大’,‘熊二’,‘光头强’))

2.索引格式化

{0} 只接收索引为0的参数

{1} 只接收索引为1的参数

…

{n} 只接收索引为n的参数

a = ‘{0},{1},{2}高高兴兴牵着手’
a = ‘{2},{1},{0}高高兴兴牵着手’
a = ‘{1},{2},{0}高高兴兴牵着手’

print(a.format(‘熊大’,‘熊二’,‘光头强’))

3.关键字格式化

a = ‘{name}头顶{pro1},身披{pro2},脚踩{pro3}’
print(a.format(name=‘狗蛋’,pro1=‘锅盖’,pro2=‘麻袋’,pro3=‘白菜’))
print(a.format(pro1=‘锅盖’,pro2=‘麻袋’,pro3=‘白菜’,name=‘狗蛋’))

4.索引，关键字混合

索引位置 必须对引号

关键字位置随意，但不能影响索引

a = ‘{0}头顶{1},身披{pro2},脚踩{pro3}’
print(a.format(‘二狗’,‘锅盖’,pro2=‘麻袋’,pro3=‘白菜’))

print( a.format( pro2=‘麻袋’, pro3=‘白菜’, ‘二狗’, ‘锅盖’) )

print( a.format(‘二狗’, ‘锅盖’, pro3=‘白菜’, pro2=‘麻袋’ ) )

5.格式限定符

{a:bcd}

a:索引/关键字

b:填充符号 默认 空字符串

c:对齐符号 左< 右> 居中^

d:总长度

如果a比d还长，那么bc就看不出来，以实际a的长度为准

如果a比d还小，那么不够的长度用b来填

a = ‘吕布带了很大的{color:"^2}{thing:>10}’
print( a.format(color=‘红色的’,thing=‘帽子’))

6.进制限定

b：二进制

o：八进制

d：十进制

x：十六进制

格式：{:b}

格式：{?}

格式：{:d}

格式：{:x}

a = ‘八戒大约体重{:d}斤’ # 将200转成十进制
a = ‘八戒大约体重{:b}斤’ # 将200转成二进制
a = ‘八戒大约体重{?}斤’ # 将200转成八进制
a = ‘八戒大约体重{:x}斤’ # 将200转成十六进制
print(a.format(200))

7.精度限定

#   格式：{:.num}      整数+小数 一共num位
#   格式：{:.numf}     小数      一共num位
a = '圆周率：{:.5}'
a = '圆周率：{:.5f}'
print(a.format(3.141592652))

8.千分位

#   , 每隔三位加一个逗号
a = '李嘉诚身价¥{:,}'
print(a.format(1000000000000000))

9.列表

1.高级操作

1 列表合并 +
a = [‘刘德华’,‘张学友’]
b = [‘郭富城’,‘黎明’]
c = a + b
print©

**2 列表重复 ***
a = [‘甄姬’,‘曹丕’]
b = a*3
print(b)

3 列表分片[start:stop:step]
a = [‘诸葛亮’,‘张飞’,‘赵云’,‘马超’,‘关羽’,‘刘备’]
print(a[:]) # 从开头 ~ 末尾
print(a[2:]) # 从索引2 ~ 末尾
print(a[:2]) # 从开头 ~ 索引2

4 成员检测 in not in
a = [‘刘备’,‘关羽’,‘张飞’,‘赵云’,‘马超’]
b = ‘曹操’ in a
b = ‘张飞’ in a
b = ‘曹操’ not in a
print(b)

2.遍历

while

for in

3.推导式

1 基本推导式

格式：[变量操作 for 变量 in 列表]

需求： 将列表中的每个值+5

a = [15,25,35,45]

原生写法

for i in range(len(a)):
​ a[i] += 5
print(a)

推导式

a = [15,25,35,45]
a = [ i+5 for i in a]
print(a)

变量每次获取列表中的一个值

2 条件推导式

格式：[变量操作 for 变量 in 列表 if 条件表达式]

格式：[变量操作(true环境) if 条件表达式 else 变量操作(false环境) for 变量 in 列表]

需求：

获取列表中的所有偶数并+5

a = [12,13,14,15]
a = [ i + 5 for i in a if i % 2 == 0]
print(a)
print(’~~~~~~~~~~~~~~~~~~’)

需求：

将列表中所有的偶数+5，其他值不变

a = [10,11,12,13]
a = [ i+5 if i%2 == 0 else i for i in a]
print(a)

3 多循环推导式

格式：[变量操作 for 变量1 in 列表1 for 变量2 in 列表2]

需求：

给下列人物配以称号，写出所有的可能

a = [‘菜鸟’,‘大神’]
b = [‘狗蛋’,‘全蛋’]
c = [ i+j for i in a for j in b]
print©

原生写法

a = [‘菜鸟’,‘大神’]
b = [‘狗蛋’,‘全蛋’]
c = []
for i in a:
​ for j in b:
​ c.append(i+j)
print©

4 多循环条件推导式

格式：[变量操作 for 变量1 in 列表1 for 变量2 in 列表2 if 条件]

格式：[变量操作(true环境) if 条件 else 变量操作(false环境) for 变量1 in 列表1 for 变量2 in 列表2]

需求：

获取索引相同的对应值

a = [‘屌丝’,‘菜鸟’]
b = [‘狗蛋’,‘全蛋’]
c = [ i+j if a.index(i) == b.index(j) else 'xx==xx’for i in a for j in b]
print©

10.元组

1.高级操作

1 合并
a = (‘佛祖’,‘普度众生’)
b = (‘达摩’,‘易筋经’)
c = a+b
print©

重复、分片、成员检测与列表一模一样,参考列表

2.遍历

a = (‘易筋经’,‘洗髓经’,‘金钟罩’,‘童子功’)
i = 0
while i < len(a):
​ print(i,a[i])
​ i += 1

for i in range(len(a)):
​ print(i,a[i])

print(’~~~~~~~~~~~~~~~~~~~~’)

for i in a:
​ print(a.index(i),i)

元组没有推导式，但后期可以通过生成器来完成类似于推导式的功能

11.字典

推导式：

1 基本推导式

格式：{键：值 for 键,值 in 字典.items()}

以下列格式进行输出：绰号=xxx 大名=xxx

a = {‘ez’:‘伊泽瑞尔’,‘妖姬’:‘乐芙兰’}
b = {‘绰号=’+k : ‘大名=’+v for k,v in a.items() }
print(b)

2 条件推导式

格式:{键：值 for 键,值 in 字典.items() if 条件}

需求：只显示名字长度为4的人

a = {‘ez’:‘伊泽瑞尔’,‘妖姬’:‘乐芙兰’}
b = {k:v for k,v in a.items() if len(v)==4}
print(b)

3 多循环推导式

格式:{键：值for键1，值1 in 字典1.items() for 键2,值2 in 字典2.items() }

a = {‘ez’:‘伊泽瑞尔’,‘妖姬’:‘乐芙兰’}
b = {‘虚空行者’:‘卡萨丁’,‘冰女’:‘丽桑卓’}
c = {v1:v2 for k1,v1 in a.items() for k2,v2 in b.items()}
print©

4 多循环条件推导式

格式:{键：值for键1，值1 in 字典1.items() for 键2,值2 in 字典2.items() if 条件}

a = {‘ez’:‘伊泽瑞尔’,‘妖姬’:‘乐芙兰’}
b = {‘虚空行者’:‘卡萨丁’,‘冰女’:‘丽桑卓’}
c = {v1:v2 for k1,v1 in a.items() for k2,v2 in b.items() if len(v1)!=4 and len(v2)!=4}
print©

12.集合

1.定义

一个值不会重复的无序序列

主要作用：去重，讲一个列表转为集合就会自动去重

关系测试 测试两个集合交集、差集等

2.基本操作

交集 &

并集 |

差集 -

成员检测 in

3.推导式

1.基本推导式

{变量操作 for 变量 in 集合}

a = {‘阿信’,‘怪兽’,‘奥特曼’}

给每个值加个小字

b = {‘小’+i for i in a}
print(b)

2 条件推导式

{变量操作 for 变量 in 集合 if 条件}

3 多循环推导式

{变量操作 for 变量1 in 集合1 for 变量2 in 集合2}

4 多循环条件推导式

{变量操作 for 变量1 in 集合1 for 变量2 in 集合2 if 条件}

13.冰冻集合

1.定义

一旦创建就无法再进行添加或删除的操作

2.格式

变量名=frozenset（可迭代的对象）

3.遍历

a = frozenset([‘整太’,‘孟祥云’,‘萝莉’,‘小娜’])
for i in a:
​ print(i)

4.推导式

格式:

frozenset(变量操作 for 变量 in 集合)

frozenset(变量操作 for 变量 in 集合 if 条件)

a = frozenset([‘整太’,‘孟祥云’,‘萝莉’,‘小娜’])
print(id(a))
b = frozenset(‘小’+i for i in a)
print(b)
a = frozenset(‘小’+i for i in a)
print(a)
print(id(a)) # 此时a不同于之前的a

13.迭代器

1.定义

可迭代对象(iterable):能够使用iter()的都属于可迭代对象

迭代器(iterator):将可迭代对象一个一个进行获取

2.使用

通过iter() 和next()

iter() 创建迭代器

next() 通过迭代器获取一个值

a = iter([1,2,3]) # 将列表送入iter(),得到"列表迭代器对象"
print(next(a)) # 通过next()获取列表迭代器中的一个值
x = next(a) #可以将得到的值存入别的变量，做任意操作

print(next(a))

print(next(a)) #此时迭代器中已经没有值，再次迭代就会报错

13.高阶函数

1.定义

1. 参数为函数

2. 返回值为函数

满足以上任意条件即可成为高阶函数

2.作用

1. 易于可读性

2. 方便代码维护

3. 隔离作用域

3.map

map（函数，可迭代对象…）

功能：对迭代器中每一个对象都使用一次函数

需求：

对1-10每个值开平方

def power(x):
​ print(’%d的平方：’%x,end=’’)
​ return x**2

for i in map(power,range(1,11)):
​ print(i) #这里的i不是1-10的值，而是经过power处理的i

def power(x,y):
​ print(’%d的%d次方：’%(x,y),end=’’)
​ return x**y

条件限制：

可迭代对象的个数必须与形参的个数一致

for i in map(power,range(1,5),range(5,9)):
​ print(i)

3.sorted

sorted(iterable,key=func,reverse=Bool)

功能：将可迭代对象进行排序，生成排好的序列

参数：

iterable：可迭代对象

key：排序依据，常用函数

如果没有key，默认使用iterable的值进行排序

key默认为None

reverse:升序/降序

升序：False默认

降序：True

返回值：排好序的可迭代对象

4.filter

filter(func,iterable)

功能：过滤迭代器重的数据，返回符合条件的可迭代对象

将可迭代对象中的数据进行判断，True则保留，否则抛弃

注意点：

func 需要返回bool，外部filter才能知道是否保留

参数：

func:内置或自定义

iterable：可迭代对象

返回值：对象

5.reduce

reduce(func,iterable)

功能：对iterable的每一个对象进行累计操作

参数：

func：内置或自定义

要求：每次必须送两人进函数，形参必须设置两个

iterable：可迭代对象

返回值：计算之后的值

注意：

reduce不是内置函数所以不能直接调用

必须提前引入模块 functools

from functools import reduce
a = [1,2,3,4,5]
def add(x,y):
​ return x+y
b = reduce(add,a)
print(b)

14.文件操作

1.打开文件

open（文件路径，打开模式）

返回值：io对象

a = open(‘a1.txt’,‘r’)

print(a)

打开模式

r：只读，指针指向开头 文件不存在则报错

w：只写，指针指向开头 文件不存在则自动创建

a：追加，指针指向结尾 文件不存在则自动创建

+：增强，将具备读和写的能力

2.读取文件

io对象.read(位数)

文件读取都是通过指针，一般指向开头

3.写入文件

io对象.write(内容)

注意： w模式会将原有内容全部删除再写入内容

w模式如果文件不存在会自动创建

a = open(‘a2.txt’,‘r’) 打开模式为r，只读，所以不能写入内容

a = open(‘a2.txt’,‘w’) #打开模式为w，可以写入内容
a.write(‘legends never die’)

4.追加模式

io对象.open(文件路径,a)

注意：a 模式会在原有内容的最后面进行添加内容，不会影响原来的内容

a = open(‘a2.txt’,‘a’)
a.write(’-i like this song’)

a = open(‘a3.txt’,‘a’)

5.增强模式

在原有的模式上加强功能 符号：+

一般情况下，带有+的模式，同时具备读和写的功能

例如：

r+

w+

a+

a = open(‘a4.txt’,‘w’)
a = open(‘a4.txt’,‘r+’) # 因为r+模式，内容会从开头依次进行覆盖，没有碰到的部分不受影响
a.write(‘123’)

a = open(‘a4.txt’,‘w+’)
a.write(‘abcdef’) # 此时全部写完后，指针到了最后

a.seek(0) #seek(0) 将指针指向开头
print(a.read())

6.二进制模式

通常读取、写入文件时，通过以string的类型进行操作

byte：以二进制进行存储，以十六进制展示 （格式： \x 十六进制）

如果以b模式打开，那么在写入内容之前必须先转为二进制

str ==> byte 需要encode()

byte ==> str 需要decode()

为什么需要byte转换：

1）正常人看不懂，得到保护数据的作用

2. 抓取的文件，有的就是二进制

3. 速度快

7.关闭文件

io对象.close()

a = open(‘a5.txt’,‘r’)

a.close()

14.文件指针

1.当前指针

io对象.tell

a = open(‘a1.txt’,‘r’)
print(a.tell()) #当前指针为0
print(a.read(2)) #读取2位，指针向后移2位
print(a.tell()) #读取指针为2

print(a.read()) #读取到最后
print(a.tell()) #读取指针是几，该文件就有多大字节
a.close()

2.移动指针

io对象.seek()
a = open(‘a1.txt’,‘r’)
print(a.tell())
print(a.read(2))
print(a.tell())
a.seek(0) #将指针移到最前面
print(a.tell())
a.seek(3)
print(a.tell())

a.read() #也可以用 read读完，将指针移到最后

15.文件内容

1.写入文件内容

io对象.write(‘内容’)
返回值：写入内容的长度
注意：
​ 会清除原有的内容，再写入新的内容
a = open(‘a2.txt’,‘w+’)
b = a.write(‘how are you’)
print(b)

a.seek(0)

2.写入文件序列

io对象.writelines（容器）
返回值：无
li = (‘床前明月光\n’,‘地上鞋两双\n’,‘床上狗男女\n’,‘其中就有你’)
li = {‘床前明月光\n’,‘地上鞋两双\n’,‘床上狗男女\n’,‘其中就有你’}
li = {‘床前明月光\n’:‘地上鞋两双\n’,‘床上狗男女\n’:‘其中就有你’}
li = [‘床前明月光\n’,‘地上鞋两双\n’,‘床上狗男女\n’,‘其中就有你’]
b = a.writelines(li)
a.close()
print(b)

3.读取文件内容

io对象.read(n)

参数：

n如果不填，默认从当前指针开始，读取到末尾

n = 1,从当前指针开始向后读取1位

n = 2,从当前指针开始向后读取2位

…

返回值：读取的内容

a = open(‘a3.txt’,‘r’)
b = a.read()
print(b)

4.读取一行内容

io对象.readline(n)

参数：

n 如果不填，从当前指针开始，向后读取一位(不会到下一行)

n = 1,从当前指针开始，向后读取1位

n = 2,从当前指针开始，向后读取2位

如果当前行没有读取完毕，下一次的readline会接着上一次继续读

如果指定n时，已经超过当前行，那么不会读取下一行的内容，只会读取当前一行

返回值：一行内容

a = open(‘a2.txt’,‘r’)

不指定n时

b = a.readline()
print(b)
b = a.readline()
print(b)
b = a.readline()
print(b)
b = a.readline()
print(b)

a.seek(0)

指定n时

b = a.read(2)
print(b)

b = a.readline()
print(b)

b = a.readline(200)
print(b)

b = a.readline()
print(b)

5.读取内容到列表

io对象.readlines()

每一行分配一个索引，存入列表中

第一行索引0

第二行索引1

…

a = open(‘a3.txt’,‘r’)
b = a.readlines()
print(b)

6.截取内容

io对象.truncate(n)

功能：从开头向后截取n个字节，剩余没有被截取的将全部删除

返回值：返回截取的长度

a = open(‘a3.txt’,‘a’)
b = a.truncate(2)
print(b)

7.刷新文件缓冲

io对象.flush()

功能: 立马将缓冲区的内容存入文件中

返回值: 无

平时文件的 写 操作, 其他不会立马把内容写入文件, 只是把内容存入缓冲区

当满足以下任意条件时, 即可将缓冲区内容存入文件中

当整个程序自然结束时

当运行到flush时

当文件关闭时

当缓冲区填满了, 将内容存入文件中, 再刷新刷新缓冲

利用pycharm, 通过断点调试来查看

8.浅谈with

在以上的操作, 经常忘记close操作, 导致内存在不断的浪费.

with 会在文件操作完之后, 自动帮你关闭文件

a = open(‘a4.txt’, ‘r’)
print( a.read() )

上面的a 没有关闭文件

with open(‘a4.txt’,‘r’) as file:
print(file.read())
pass

上面的file 已经帮你关闭的文件

在整个with的过程中, 没有close, 但是, with的代码块全部执行完时, 自动执行file.close()操作。

16.模块

1.定义

模块是一个包含所有自定义的函数、类和变量的文件

当模块被别的程序引入时，便可以使用该模块的任意函数和变量

Python系统标准库，也是这么引用的

2.格式

2.1 引用模块

2.2 引用模块中的方法/变量

2.1 引用模块

import 模块名

import.方法名()

import.变量名

import demo

print(demo.name)
print(demo.monney)
demo.skill()

2.2 引用模块中分方法/变量

from 模块名 import 方法名

from 模块名 import 方法名1，方法名2,…

from 模块名 import 变量名

from 模块名 import 变量1,变量名2,…

from demo import skill
skill()

skill2()

from demo import skill,skill2
skill()
skill2()

from demo import import name
print(name)

from demo import name,money
print(name)
print(money)

小结：

单纯的import,是引入整个模块文件

from … import …,只引用模块中的某些方法/变量

3.路径

import 的模块都存在哪里，从哪里引入的？

查看路径

import sys
print(sys.path)

可以看到有一下几个目录：

有Python37-32\ 安装的根目录

有Python37-32\DLLs

有Python37-32\lib

有Python37-32\lib\site-packages\

当前目录下 (该运行文件的目录下)

4.属性

作用：自动获取当前模块/引用模块的名字

如果是自身文件被运行，name 返回 main 代表正在运行的是当前主程序

如果是被别的模块引入,__name__返回引入模块的名字

import demo

demo.skill3()

使用案例：

模块A被模块B第一次引入时，模块A的主程序将会主动执行

现在想要模块A被引入时，模块A的部分不想运行

5.标准模块

1.string模块

简述：字符串相关的功能

import string

a = string.ascii_letters # 获取所有的字母(包含大小写)
a = string.ascii_uppercase # 获取所有的大写字母
a = string.ascii_lowercase # 获取所有的小写字母
a = string.digits # 获取所有的数字
a = string.octdigits # 获取所有的八进制数字
a = string.hexdigits # 获取所有的十六进制数字
a = string.punctuation # 获取ascii码中所有符号，标点
a = string.whitespace # 获取所有的空白 空格，制表符，换行等
a = string.printable # 获取所有的字符
print(a,type(a))

2.随机模块

1.random模块：随机数模块
import random

获取0-1之间的随机数

a = random.random() #(0,1) 含有小数
print(a)

获取0-1之间的随机数

a = random.randrange(0,2) #[0,2)
print(a)

获取0-10之间的随机数

a = random.randrange(0,11) # [0,10]
print(a)

获取1-10之间的随机整数

a = ranom.randint(1,10) #[1,10]
print(a)

获取1-10之间的随机小数

a = random.uniform(1,10) #[1,10]
print(a)