当列表发生变化时，它不会产生新的值，而是会改变自己

• 取值

方法一：索引取值 eg：

l1 = [11, 22, 33, 44, 55, 66] print(l1[1])  # 22 print(l1[-2])  # 55 负号控制方向 

注：值从0开始，不是常规思想，从1开始

方法二:切片取值(取多个值) eg：

l1 = [11, 22, 33, 44, 55, 66] print(l1[0:4])  # [11, 22, 33, 44] print(l1[-4:-1])  # [33, 44, 55] print(l1[0:4:2])  # [11, 33] 第三个数2代表间隔值 print(l1[-1:-3:-1])  # [66, 55] 负数可以改变方向 

重要的内置方法

• append

  在最后添加一个数据值，如果你是列表，字典也将整个数据值添加到最后 

eg：

l1 = [11, 22, 33, 44, 55, 66]
l1.append([1, 2, 3])
print(l1)  # [11, 22, 33, 44, 55, 66, [1, 2, 3]]

• insert

  在任意位置添加一个数据值，也是把整体当作一个数据值追加
  

eg：

l1 = [11, 22, 33, 44, 55, 66]
l1.insert(1, [1, 2, 3])
print(l1)  # [11, [1, 2, 3], 22, 33, 44, 55, 66]

• extend

  在末尾追加，但是这个跟前两个不太一样，如果出现列表和字典等，是将里面的数据值挨个加入进去
  

eg：

l1 = [11, 22, 33, 44, 55, 66]
l1.extend([1, 2, 3])
print(l1)  # [11, 22, 33, 44, 55, 66, 1, 2, 3]

entend也可以是for+append的作用，先循环取值，然后在逐个添加进去

• del

  通过索引删除
  

eg：

l1 = [11, 22, 33, 44, 55, 66]
del l1[2]
print(l1)  # [11, 22, 44, 55, 66]

• pop

  将值踢出去，还可以使用
  

eg：

l1 = [11, 22, 33, 44, 55, 66]
l1.pop(2)
print(l1)  # [11, 22, 44, 55, 66]
print(l1.pop(2))  # 44

如果你不给索引值得话，就是默认为删除末尾的数据值

• remove

  指名道姓的删除
  

eg：

l1 = [11, 22, 33, 44, 55, 66]
l1.remove(22)
print(l1)  # [11, 33, 44, 55, 66]

• count

  统计重复的数据值的个数
  

eg：

l1 = [11, 22, 33, 33, 22, 33, 11, 11, 22, 22, 33]
print(l1.count(33))  # 4

了解的内置方法

• reverse

  反转180°
  

eg：

l1 = [11, 22, 33, 44, 55, 66]
l1.reverse()
print(l1)  # [66, 55, 44, 33, 22, 11]

• sort

  从低到高的排序
  

eg：

l1 = [33, 11, 22, 66, 55, 44]
l1.sort()
print(l1)  # [11, 22, 33, 44, 55, 66]

当然还有从高到低

l1 = [33, 11, 22, 66, 55, 44]
l1.sort(reverse=True)
print(l1)  # [66, 55, 44, 33, 22, 11]

• index

  查看数据值所在的索引值
  

eg：

l1 = [33, 11, 22, 66, 55, 44]
print(l1.index(66))  # 3

• 类型的转换 能被for循环的数据类型都能转换成元组 关于元组，当括号里只有一个值得时候，要加逗号，不然就会被认为是整型
• 取值

l1 = (1,2,3,4,5)
print(l1[1])  # 输出结果：2

统计元组内的数据值个数

l1 = (1, 2, 3, 4, 5)
print(len(l1))  # 输出结果：5

• 改

元组的数据值是不会被修改的 元组的索引不会改变绑定的地址

当元组内出现其他数据类型的时候

eg：

l1 = (1, 2, 3, 4, 5, [11, 22, 33, 44, 55, 66])
l1[-1][3] = 666  # 这里我们找的值是列表的值
print(l1)  # 输出结果：(1, 2, 3, 4, 5, [11, 22, 33, 666, 55, 66])

字典中，KV键值对是无序的 字典中的K值一般为字符串，所以很少用到类型转换

• 取值

  建议用get方法，因为这样即使你没有这个K值，也不会报错
  

eg：

l1 = { 
        'name': 'jason', 'pwd': 123, 'hobby': 'read'}
print(l1.get('name'))  # jason

• 修改数据

  健在为修改，健不在为新增
  

eg：

l1 = { 
        'name': 'jason', 'pwd': 123, 'hobby': 'read'}
l1['name'] = 'kevin'  # 修改K值对应的V值
print(l1)  # {'name': 'kevin', 'pwd': 123, 'hobby': 'read'}

eg2：

l1 = { 
        'name': 'jason', 'pwd': 123, 'hobby': 'read'}
l1['name1'] = 'kevin'  # 修改K值对应的V值
print(l1)  # 输出结果：{'name': 'jason', 'pwd': 123, 'hobby': 'read', 'name1': 'kevin'}

• .update

  健在为修改，健不在为新增
  

eg：

l1 = { 
        'name': 'jason', 'pwd': 123, 'hobby': 'read'}
l1.update({ 
        'name': 'kevin'})
print(l1)  # {'name': 'kevin', 'pwd': 123, 'hobby': 'read'}

eg：

l1 = { 
        'name': 'jason', 'pwd': 123, 'hobby': 'read'}
l1.update({ 
        'name2': 'kevin'})
print(l1)  # {'name': 'jason', 'pwd': 123, 'hobby': 'read', 'name2': 'kevin'}

• 删除数据

del eg：

l1 = { 
        'name': 'jason', 'pwd': 123, 'hobby': 'read'}
del l1['name']
print(l1)  # {'pwd': 123, 'hobby': 'read'}

pop eg：

l1 = { 
        'name': 'jason', 'pwd': 123, 'hobby': 'read'}
l1.pop('name')
print(l1)  # {'pwd': 123, 'hobby': 'read'}

popitem

随机删除

eg：

l1 = { 
        'name': 'jason', 'pwd': 123, 'hobby': 'read'}
l1.popitem()
print(l1)  # {'name': 'jason', 'pwd': 123}

• 快速构造字典

fromkeys

eg：

print(l1.fromkeys(['name'], { 
        'jason', 'kevin', 'tony'}))  # {'name': {'jason', 'tony', 'kevin'}}

• 快速获取键值对

K值 eg：

l1 = { 
        'name': 'jason', 'pwd': 123, 'hobby': 'read'}
print(l1.keys())  # dict_keys(['name', 'pwd', 'hobby'])

V值 eg：

l1 = { 
        'name': 'jason', 'pwd': 123, 'hobby': 'read'}
print(l1.values())  # dict_values(['jason', 123, 'read'])

• 类型转换 能被for循环的数据类型都可以转换成集合

• 去重

eg：

l1 = { 
        1, 2, 3, 3, 4, 3, 2, 3, 4, 1, 3, 4, 3, 4, 5, 5}
print(l1)  # 输出结果：{1, 2, 3, 4, 5}

• 关系运算

QQ好友推送

pythons = { 
        'jason', 'oscar', 'kevin', 'ricky', 'gangdan', 'biubiu'}
linuxs = { 
        'kermit', 'tony', 'gangdan'}
print(pythons & linuxs)  # 两个的共同好友
print(pythons | linuxs)  # 所有的名字
print(pythons - linuxs)  # 第一组数据独有的名字
print(pythons ^ linuxs)  # 在两组数据中没有同时出现的数据

• 语言介绍

    python会自动帮我们清理那些没有被绑定的数据值(使用不了的)，这样更能释放内存的空间，
    保证电脑的性能。
  

• 机制的三个阶段

  引用计数 什么叫引用计数？就是统计那些数据值身上的绑定值是多少个；如果是0，那就为垃圾，相反，则继续保留。 这里还有一个坑，叫循环引用

  标记清除 专门解决第一阶段的循环引用，将内存中产生的所有值都检查一遍，观察是否存在循环引用，如果有就做上标记，之后再一次清除。 处理循环的引用的 分代回收 将标记起来的每隔一段时间检查一遍，然后将计数为一个清除掉，但是这样消耗的大 为了减轻垃圾回收机制的消耗，然后发明了三大管理来解决资源消耗的问题 越往下检测频率越低

就是通过二进制0，1组成的编码串，形成我们能够看的懂得东西，那么我们还需要属于自己得编码本

计算机是由美国人发明的，所以刚开始，只有属于英文的编码本，但是随着我们国家的强大，也可以用计算机了，然后我们也发明了属于自己的编码本。

字符编码的发展史一共分为三个阶段： 1.一家独大 计算机是由美国发明的，所以刚开始就只有英文的编码本（ASCII码）；ASCII码里只有英文字母与字符的编码信息 用1bytes来存储字符 需要我们记住的：A-Z：65-90；a-z：97-122

2.群雄割据 随着时代的发展，我们国家和其他一些国家的快速发展，我们也可以用电脑了。但是电脑只有关于英文的翻译，却没有属于自己文字的编码本。所以我们就自己发明自己的编码本。 中国：GBK （里面存储中文） 至少用2bytes来存储字符 韩国：Euc_kr

3.天下一统 各用各的不能联立起来，别人的发给我，我翻译不了 于是发明了万国码 万国码(unicode):兼容万国字符;解决了不能兼容的问题 存储数据的话至少2bytes起步，但是英文还是一个。 utf是针对unicode的优化版本，主要是utf8 注意：内存用unicode，硬盘用utf8

只有字符串才能参与编码，其他类型需要先转换成字符串才可以编码

• 编码(encode)

  就是用我们的字符去让计算机看懂我们的意思
  

• 解码(dencode)

  相反，就是计算机的字符转换成我们能看懂的字符
  

当出现乱码的时候，是用什么类型编的，就用什么类型解 基于网络的传输，数据值必须是二进制

eg：

s1 = '加油干'
res1 = s1.encode('gbk')
print(res1)  # 编码
res2 = res1.decode('Euc_kr')
print(res2)  # 乱码
res3 = res1.decode('gbk')
print(res3)  # 正常输出

python2解释器默认的编码是ASCII码 python3解释器默认的编码是utf8

在python2中，如果你想编写代码，那么你需要在代码第一行加上 coding:utf8 -*- coding:utf8 -*- # 美化版本 而且在写字符串的时候，在前面还要加一个u

• 什么是文件

  就是操作系统提供给用户可以直接操作硬盘的快捷方法
  

• 代码操作文件流程

  1.创建文件
  2.打开文件
  3.编辑文件
  4.保存文件
  5.关闭文件
  

• 结构

f.open() # 打开文件 f.close() # 关闭文件 推荐使用 with open () as f: pass

注意 使用关键字打开文件,填写路径为了防止特殊符号,可以在前面加r eg：

open(r'a.txt')  # 相对路径
open(r'D:\python\day09\a.txt')  # 绝对路径
res = open(r'a.txt', 'r', encoding='utf8')

主要是with上下法

• 格式

 with open（r'', '', encoding='utf8') as 变量名：
 	pass  # 为了补全代码的格式，让其不会报错，但实际没有任何代码意义
 	...  # 这种也是可以

读写功能 r： 只有读的权限，默认模式 w：只有写的权限 a：只有写的权限，与w有所区别

• r

文件路径的时候，会读出文件信息，但是文件路径不存在的时候，会报错

• w

文件路径存在的时候，往文件里写东西的时候，会先清空文件内容，然后再添加进去；当文件路径不存在的时候，也不会报错，会自动新建一个文件

• a

文件路径存在的时候，不会先清空文件内容，而是直接在文件的末尾加，不会换行，如果我们想换行，需要加\n；文件路径不存在的时候，也会自动创建一个文件

• t

  文本操作的默认模式
  

其实上面的读写模式，都是rt，wt，at，只是将t隐藏起来了。 这个模式只支持文本操作。 这个模式操作时，必须加encoding='utf8' 而且读写都是以字符串为单位

• b

  二进制模式
  

任何模式都可以 当要用这种模式的时候，必须加b，不能被省略 这个模式的时候，不用加encoding='utf8' 读写都是以bytes为单位

eg：

with open(r'1.jpg', 'rb') as f:
    data = f.read()
    print(data)

图片的二进制情况下的输出结果

• 原理

  1.数据修改的原理不是断开然后再加，而是让要修改的地方模糊，然后再修改（覆盖写）
  2.数据的删除，是由占有态变为自由态；

分为两种： *1.覆盖写： 先读取文件的内容，在内存中修改之后，然后利用w模式打开写入 优点：只会占一块空间，更节省内存 缺点：当数据量过大的时候，会导致内存溢出。 2.重命名 先读取到内存，在内存中修改，然后保存到另外一个文件里 优点：不会造成溢出 缺点：会更占内存

当我们覆盖写的时候，字符串的情况下，会产生新的值，所以需要重新赋值；不可变数据类型就不用，比如列表

• 理解

  相当于是包装一个代码过程，如果后面相使用这代码效果的时候，就可以直接使用这个包装。这样可以节省代码量。
  

其实print，input，len…这些方法都是函数的内置方法

1.循环 在相同的位置反复执行相同的代码 2.函数 在不同的位置反复执行想同的代码

• 关键字

  def

• 格式

def 函数名():
	函数体代码

函数名()函数的调用

• 关键字 def

• 理解

  就相当于是我们提前打造好工具，以后直接使用就好了；没有函数的时候，当我们每次都要使用工具，
  都要搭火制造
  

注意：函数一定要先定义再使用，否者就会报错

• 函数的定义

def 函数名():
	pass  # 补全代码的语法结构

函数名()  # 调用函数使用

• 结构

def 函数名(参数1，参数2):
	# 注释
	函数体代码
	return 返回值

函数在定义的时候只检测函数体语法，不执行函数体代码，只有在调用函数的时候才会去执行代码。 当我们不调用函数的时候，是不会执行函数体代码的，也不会报错

当我们调用函数的时候，就会报错

函数名的含义：函数名就是在内存里绑定一个地址，里面存放函数体代码，想要使用就需要调用函数

函数名加括号的优先级更高(不包括定义阶段)

函数分为自定义函数和内置函数

• 内置函数

  内置函数就是已经被制造好的函数，已经被定义好了的，我们直接调用就使用的
  

列如：open(), len(),print()…

注意：内置函数可以直接调用，但是数据类型的内置方法(函数)，必须使用数据类型加点.的方式才可以被调用，相当于数据类型独有的一些内置方法

• 自定义函数

  就是需要我们自己去定义的函数，自己去创造
  

1.空函数

函数体代码使用pass顶替，暂时没有任何功能。所以我们会下意识觉得空函数没有什么作用， 但是，空函数相当有用，前期可以帮助我们搭建项目功能，有助于我们的代码结构思考。

def run():

pass

2.无参函数

函数定义阶段括号内没有任何的参数

def run():

print('加油！')

3.有参函数 函数定义阶段括号内填写参数，用于接收外界传给内部的代码数据值

def index(a,b):

print('加油！')

有参函数调用需要函数名加括号并且给函数值

• 理解

    返回值就是调用函数之后产生的结果，可有可无。
    获取函数返回值的方式是固定的
    变量名 = 函数()
    如果没有则默认为接收None
  

• 关键字 return

函数体内没有return，默认返回None 函数体内有return，但是后面没有值，也是返回None 函数体内有return，后面跟着有值，那么就返回这个值 函数体内有return，后面跟的是变量名，那么就会返回这个变量名对应的数据值 函数体内有return，后面跟着多个数据值，那么需要用逗号隔开

注意：默认情况下返回的是一个元组

当然，我们也可以自定义返回数据类型 eg：

def index():
    return { 
        'name': 'jason', 'pwd': 123}


data = index()
print(data)  # {'name': 'jason', 'pwd': 123}

函数体内有return时，遇到return时，会结束，就可以比喻是循环中的break

函数的参数分为形式参数和实际参数

形式参数

写在函数名后括号里的，简称‘形参’