第三周总结

2022-07-03 19:36:15 作者：互联网

第三周周末总结

列表元组集合字典的内置方法

列表的内置方法

1.增
	1.1oppend()列表末尾增加数值
        l1 = [1, 2, 3, 4]
        l1.append(5)
        print(l1)
       """[1, 2, 3, ,4, 5]"""
	1.2extend()列表末尾增加多个数据值
    	  l1 = [1, 2, 3, 4]
        l1.extend(5, 6, 7)
        print(l1)
        """[1, 2, 3, 4, 5, 6, 7]"""
	1.3insert()列表末尾插入元素此元素位置可定义
    	  l1 =[1, 2, 3, 4]
        l1.insert(1, 'joseph')
        """[1, 2, 'joseph', 3, 4]"""
2.删
	2.1del()删除指定列表中的数值
    	  l1 = [1, 2, 3, 4]
        l1.del(2)
        print(l1)
        """[1, 3, 4]"""
	2.2pop()默认自动弹出列表中最后一个是数值
    	  l1 = [1, 2, 3, 4, 5]
        l1.pop()
        print(l1)
        """[1, 2, 3, 4]"""
        
        l1 = [1, 2, 3, 4, 5]
        l1.pop(1)
        print(l1)
        """[1, 3, 4, 5]"""
	2.3remove删除已知定义的数值
    	  l1 = [a, b, c, d, e, f]
        l1.remove(c)
        print(l1)
        """[a, b, d, e, f]"""
3.升序倒叙
	3.1reverse将整个列表前后颠倒排序
    	  l1 = [1, 2, 3, 4, 5, 6]
        l1.reverse()
        print(l1)
        """[6, 5, 4, 3, 2, 1]"""
	3.2sort将整个无序列表进行排序
    	  l1 = [22, 666, 77, 520, 11, 521]
        l1.sort()
        print(l1)
        """[11, 22, 77, 520, 521, 666]"""
	3.3将reverse判定为True那么就会将无序列表按照从大到小的顺序排序
    	  l1 = [22, 666, 77, 520, 11, 521]
        l1.sort(reverse=True)
        print(l1)
        """[666, 521, 520, 77, 22, 11]"""

元组的内置方法

1.索引取值
	data = [1, 2, 3, 'joseph', 4, 5 ]
   print(data[3])
	"""'joseph'"""
   print(data[-2])
	"""'joseph'"""
2.切片
	data = [1, 2, 3, 'joseph', 4, 5, 6 ]
   print(data[0, 5, 2])
	"""1, 3, 4, 6"""
3.长度
	data = [1, 2, 3, 'joseph', 4, 5 ]
   print(len(data))
	"""6"""
4.成员运算
	data = [1, 2, 3, 'joseph', 4, 5 ]
   'joseph' in data:
    True
    'joseph' not in data:
    False
5.循环
	data = [1, 2, 3, 'joseph', 4, 5 ]
   for i in data:
   """
   1
   2
   3
   joseph
   4
   5
   """

集合的内置方法

1.合集(|)
	pythons={'jason','oscar','kevin','ricky','gangdan','biubiu'}
	linuxs={'kermit','tony','gangdan'}

	print（'pythons'|'linuxs'）
	{'tony', 'jason', 'oscar', 'gangdan', 'kermit', 'biubiu', 'kevin', 'ricky'}
2.交集(&)
	pythons={'jason','oscar','kevin','ricky','gangdan','biubiu'}
	linuxs={'kermit','tony','gangdan'}

	print('python'&'linuxs')
	{'gangdan'}
3.差集(-)
	pythons={'jason','oscar','kevin','ricky','gangdan','biubiu'}
	linuxs={'kermit','tony','gangdan'}

	print('pythons'-'linuxs')
	{'jason', 'oscar', 'biubiu', 'kevin', 'ricky'}

4.对称集(^)
	pythons={'jason','oscar','kevin','ricky','gangdan','biubiu'}
	linuxs={'kermit','tony','gangdan'}

	print('pythons'^'linuxs')
	{'tony', 'jason', 'oscar', 'kermit', 'biubiu', 'kevin', 'ricky'}

5.值是否相等(==)
	pythons={'jason','oscar','kevin','ricky','gangdan','biubiu'}
	linuxs={'kermit','tony','gangdan'}

	print('pythons'=='linuxs')
	False

字典的内置方法

1.按k取值
	1.按k取值
    dict = {'name':'joseph','age':'21', 'hobby':['read', 'play games'] }
    print(dict('name'))
    'joseph'
    print(dict('hobby')[1])
    'play games'

    2.给字典增加键值对
    dict['gender'] = 'male'  
    print(dict)
    {'name': 'joseph', 'age':'21', 'hobby':['read', 'play games'], 'gender':'male'}

    3.
    dict['name'] = 'alex'
    print(dict)
    {'name': 'alex', 'age':'21', 'hobby':['read', 'play games'], 'gender':'male'}
2.len长度
    dict = {'name':'joseph','age':'21', 'hobby':['read', 'play games'] }
    len(dict)
    3
3.成员运算
    dict = {'name':'joseph','age':'21', 'hobby':['read', 'play games'] }
    'name' in dict
    True
4.删除
    dict = {'name':'joseph','age':'21', 'hobby':['read', 'play games'] }
    dict.pop('name')
    print('dict')
    {'age':'21', 'hobby':['read', 'play games']}
5.取所有值
dict = {'name':'joseph','age':'21', 'hobby':['read', 'play games'] }
1.取所有的k值
dict.keys()
['name', 'age', 'hobby']

2.取所有的v值
    dict.values()
    ['joseph', '21', ['read', 'play games']]

    3.取所有的kv
    dict.items()
    ['name':'joseph','age':'21', 'hobby':['read', 'play games'] ]
6.循环
dict = {'name':'joseph','age':'21', 'hobby':['read', 'play games'] }
1.默认循环的值是字典的k值
    for key in dict.keys()：
        print(key)
    'name'
    'age'
    'hobby'

    2.只循环v值
    for key in dict.values():
        print(key)
    'joseph'
    '21'
    ['read', 'play games']

    3.循环k，v键值对
    for key in dic.items():
        print(key)
    'name':'joseph'
    'age':'21’
    'hobby':['read', 'play games'] 
7.get（增加）
	dict = {'name':'joseph','age':'21', 'hobby':['read', 'play games'] }
	dict.get('name')
	'joseph'  # key存在，则获取key对应的value值
	data=dict.get('XXX') # key不存在，不会报错而是默认返回None
	print(data)
	None  
	data=dic.get('gender','male') # key不存在时，可以设置默认返回的值,如果遇到没有的k，v键值对那
  么就会直接给上方字典增加进去
	print(data)
	male 
	# ps:字典取值建议使用get方法
8.pop（弹出）
	# 固定选取k值将选区的kv键值对弹出，可以进行存储
    dict = {'name':'joseph','age':'21', 'hobby':['read', 'play games'] }
    value = dict.pop('age')
    print(dict)
    ['name':'joseph', 'hobby':['read', 'play games'] ]
    print(value)
    'age':'21'
9.popitem（随机弹出）
# 随机弹出一个键值对，也可以使用变量名去存储
    dict = {'name':'joseph','age':'21', 'hobby':['read', 'play games'] }
    item = dict.popitem()
    print(dict)
    ['name':'joseph', 'hobby':['read', 'play games'] ]
    print(item)
    'age':'21'
10.update（替换或新增）
    # 使用新字典换旧字典，如果旧字典中没有那么就会新增一个字典
    dict = {'name':'joseph','age':'21', 'hobby':['read', 'play games'] }
    dict.update('name':'alex', 'gender':'male')
    print(dict)
    ['name':'alex','age':'21', 'hobby':['read', 'play games'] , 'gender':'male']
11.fromkeys（定义替换key值）
    # 定义替换字典中的v值
    dict = {'name':'joseph','age':'21', 'hobby':['read', 'play games'] }
    dict = dict.fromkeys(['name', 'age', 'hobby'], [])
    print(dict)
    ['name':[],'age':[], 'hobby':[] ]
12.setdefault（获取值如果没有这个字典那么新增）
# 键存在则获取键对应的值 键不存在则设置 并返回设置的新值
    dict={'name':'joseph', 'hobby':['read', 'play games'] }
    data=dict.setdefault('age','21')
    print(data)
    '21'
    dict # 字典中新增了键值对
    ['name':'joseph','age':'21', 'hobby':['read', 'play games'] ]

可变类型与不可变类型

1.可变类型与不可变类型的定义
	1.1可变类型
		值发生改变但是内存地址却不变的值都属于可变类型。例如：列表，字典，元组，集合等
   1.2不可变类型
		值发生改变内存地址也发发生改变的类型叫做可变类型，即直接创造了一个新的值。例如，整型，
  	浮点型，字符串
2.数据类型
    >>> num = 8
    >>> print(id(num))
    140711988299648
    >>>
    >>> num = 10
    >>> print(id(num))
    140711988299712
    >>>
    # 在整数中更改了数值那么他的地址就直接发生了改变所以它属于不可变数值，浮点数和整数一样都会改变
    id地址
3.可变类型
        >>> list = [11, 22, 33,]
    >>> id(list)
    2347790860480
    >>>
    >>> list[2] = '55'
    >>> id(list)
    2347790860480
    >>>
    >>> list[1] = '77'
    >>> id(list)
    2347790860480
    >>>
    # 我们更改列表中任意一个数值他的地址没有发生任何变化，即id没变，所以列表属于可变类型，元组和字典和列表
    # 一样改变其中一个数值他的地址不会变所以元组和字典也都属于可变类型
4.不可变类型
    >>> str = 'joseph'
    >>> id(str)
    2347791156336
    >>> str = 'alex'
    >>> id(str)
    2347791156656
    >>>
    # 在字符串中我们更改了他的数值，他的地址发生了变化所以它属于不可变数据类型

回收机制与预设编码

垃圾回收机制

1.引用计数
	当我们给一个数据值绑定一个变量名时那么就相当于给他绑了一条线我们通过这个线就可以找到这个数据值，当同一个数据
  值绑定有多个变量名时那么他就拥有了多个计数，当我们给两个变量相互绑定的话那么这个数据值就会直接拥有三
  个引用计数两个是变量名绑定的计数而另一个则是根据数据值相互绑定的，当我们将这两个数据值的变量名都删除
  那么就剩下两个数据值相互绑定而我们又无法调用这两个数据值那么我们就会认为他是个垃圾但是因为有引用计数
  正常删除不掉，这种情况被称为循环计数
2.循环引用
	当我们遇到循环计数时，正常的删除方式排查不到上方那种情况，因为两个数据值相互绑定会被系统默认为
  这个数据值可能还会需要，所以就需要尽量少造成这种循环。
3.标记清除
	标记清除就是为了专门解决循环计数这种形式的形式的数据垃圾，当我们计算机进行扫描是否存在垃圾数
  据时就会将很久不用的垃圾数据打上标记，如果在下个循环排查中还是没有使用到的话那么就会将他删除，但是每
  次都全局扫描一遍有点太浪费计算机资源所以就需要分类排查。
4.分代回收
	当我们遇到新生数据时那么我们就会定一个阀值我们给它定义为新生代，到了多长时间就会去自动循环排
  查它一次如果在这段时间，多次使用的话那么就会将这个数据丢入下一个阀值中名叫青春代阈值，这个阈值中排查
  速度放缓，大概十五到二十分钟才会自动循环排查一次，如果这个数值在这个阈值中还是被经常使用的话那么这个
  数据值就会被丢入下一个阈值中名叫老年代，在这个阈值中就会很长时间才会去排查一次大概四十分钟到一个小时
  左右。我们称这三个阈值为分代回收，也叫做三分代回收。

字符编码的简介

1.字符编码其实就是将我们的语言用一种底层编码形式记录成二进制语言的形式，我们将二进制0和1进行预设编码于
人类能够看懂的语言一一对应，能够让我们使用我们的语言计算机也能够听懂
2.全世界第一台计算机"ENIAC"是在美国的宾夕法尼亚大学诞生的发明人是是美国人莫克利(JohnW.Mauchly)和艾克特
(J.PresperEckert)，由于是在美国发明的那么美国就像要发明一种编码形式可以让计算机听得懂英语，所以在1950年
后期由美国国家标准协会制定的，标准的单字节字符编码方案就是我们初代使用的《ASCII》编码

3.由于是在美国诞生的所以当时美国只发明了针对英文的编码方式，而英文所有的字符只有127（2**7）个所以他们只
发明了八位字节编码，已预料可能需要增加否则七位即可。
	ASCII码:内部只记录了英文字符与数字的对应关系
	1bytes来存储字符
	A-Z  65-90
	a-z  97-122
4.后来在二战后有越来越多的国家发展起来，也使越来越多的家庭富裕起来电脑也就开始慢慢进入越来越多人的家里，
因为那个时候只有ascii嘛都是用英文来编写所以各个国家为了方便所以都开始研究自己的字符编码形式
  中国  GBK编码格式  可以识别中文编码的格式，其中也包含了英文和数字
  韩国  Euc_kr编码格式  可以识别韩文编码的格式，同样包含英文和数字
  日本  shift_jis编码格式  可以识别日文编码格式，包含英文和数字
  越来越多的国家发明了自己的编码格式所以在双方互相交流时出现乱码的情况，所以急需一个将世界上所有的
  文字都进行编码的编码预设。
5.世界上的编码形式越来越多但是之间来回转换非常的麻烦还经常出现乱码现象所以就急需要开发一种能够识别世界
上所有文字的编码形式在各界的努力下，最终unicode编码形式应运而生但是因为unicode占用资源较多所以后来又
开发了我们常用字符多的一种编码形式utf家族。最尝使用的时utf8。我们内存中一般编码形式都是Unicode，而硬
盘中我们经常使用的则是utf8的形式

文件读写模式与操作方法

文件操作简介

使用open关键字打开文件后面需要跟（要打开的文件名+文件路径+字符编码格式）
进入读写模式
1.方式1
  f = open(文件名+路径+编码（utf-8）)
  f.close
2.方式2
  with open(文件名+路径+编码)as f：
  在with as 结构中运行结束后会自动使用close结束

文件操作的读写模式

1.只读模式
	我们在这个模式中只可以读取文件中的内容并不能修改内容
2.只写模式
	我们在这个模式中只可以修改文件但是如果之前文件中有东西的话，就会被直接覆盖删除
3.只追加模式
	我们在这个模式中只可以追加写东西如果之前这个文件有东西的话直接在这个文件的末尾开始书写

文件操作实例

1.文件操作模式
	在文本模式操作时只能够修改文本
   在模式背后必须要跟encoding+编码格式
	文本模式读取文件时只能读取字符串
	简写：r		全拼：rt			(读取文件)
  	简写：w		全拼：wt			(书写文件)
	简写：a		全拼：at			（追加书写文件）
2.二进制操作模式
	二进制模式中必须写全拼如果只写单拼的那么就会进入文本操作模式
	二进制模式中能够操作所有形式的文件格式
   二进制模式中不需要添加别的编码格式
	在二进制模式中存储单位为bytes
	全拼：rb			(读取文件)
	全拼：wb			(书写文件)
	全拼：ab			（追加书写文件

操作文件的诸多方法

read（）		  读取
"""在读取模式中如果文件数据较大时就不建议一次性读取所有的文件尽量分批次去读取这个文件否则容易将内存卡爆"""
readline()		一行一行读取
"""每运行一次那么才会读取一行内容"""
readlines()		一行一行读取知道读取所有行读取完以列表形式返回
readable()		是否可以读取
write()			书写
writeable()		是否可以书写
writelines()	一行一行书写，所以在这个模式可以同时兼容多种格式的文件
flush()			输入这个命令就相当于我们在编写文本文件时按了一次Ctrl+S

文件修改与函数简介

文件内光标的移动

1.tell
	在我们使用tell关键字时可以帮我们查看我们的光标的所在位置但是返回的值是bytes
2.seek的简介
    2.1.offset
        可以控制文件中光标的移动，可以自己定义数字但是一定要注意二进制模式中如果是汉字的话一个字
  就差不多是三个字节不过输入不完整的话那么就会好不留情的报错。
    2.2  whence
        控制光标移动的起始位置
        2.1		0		在起始位是0时那么就会自动将光标移动到整个文本文件的开头部位置
        2.2		1		在起始位是1时那么就不会改变光标原本在哪里就会继续在哪里
        2.3		2		在起始位是2是那么就会自动将光标移动到整个文本文件的末尾部位
    """
    0和1都必须在二进制模式下才可以使用
    offset是可以填写负数的
    """
    with open(r'a.txt', 'r', encoding='utf8') as f:
        real_data = f.read(10)
        print(real_data)
        f.seek(0, 0)
        print(f.read())
    """abc乱花渐欲迷人眼"""
    """abc乱花渐欲迷人眼， 浅草才能没马蹄"""

机械硬盘的存储原理

1.覆盖式删除
	当我们需要在这块硬盘上进行保存时就会在某个存储位置上重新覆盖上新的数据那么之前的文件就会被删除
2.重命名式删除
	我们将需要删除的位置打上标记然后定义为自由态形式，然后我们就不会读取到这个形式的数据，但是这个
  数据本质上并没有删除所以我们有时候拿电脑或者手机去修的时候有可能被还原曾经已删除的文件，例如（老拜登
  儿子亨利拜登的事件）如果有需要用到别的数据时那么就有可能将这个自由态数据覆盖掉

函数的基本认识与函数参数简介

函数简介

1.我们使用函数是为了避免重复劳动而浪费劳动力，我们可以使用函数将需要重复的代码自己定义为函数，直接从
下方调用函数即可省下重复劳动
2.函数与循环的区别
	循环是将一段代码在这个循环内不停的重复执行直到这个条件满足或者强制结束循环才会停止
   函数则是可以直接定义和调用这段重复代码在不同位置执行

函数的本质

1.函数的本质其实就是可以为了帮我们剩下重复劳动的一种工具形式
2.函数需要提前定义就相当于我们的工具，我们要使用这个工具就需要先拥有这个工具再去使用
3.我们拥有这个工具只要遇到和这个工具适用的时候就拿出来使用简洁的解决这个问题如果我们遇到一个一起拿都没
有遇到的问题并且接下来都要使用那么我们也可以定义一个方便接下来的使用

函数的语法结构

1.定义函数
关键字（def）+函数名+（形参1+形参2  ...）
	"""函数注释"""
    函数体代码
    return 返回值
2.
	2.1.函数的定义符  （def）  # 使用这个符号表明这个是你创建了一个函数
	2.2函数名  # 函数名和我们的变量名基本相同在起函数名时也需要遵守见名知意的方法
	2.3括号（）  # 在函数定义的过程中必须要加括号如果不加括号那么这个函数就不成立
	2.4参数  # 参数内可以填写参数用来定义如果下方有人要调用这个函数时那么就需要满足这个参数的条件
  才可以调用这个函数不过这个参数也可以不填参数
	2.5函数注释  # 函数注释就像是说明书是为了你以后要是忘记了这个函数是什么时看到第一眼就能了解，
  主要是用来介绍函数的基本功能和用法
	2.6函数功能  # 函数中最为重要的用来编写你以后需要使用你所定义的这个函数的功能
	2.7return功能  # return控制函数的返回值如果有值跟在return后方那么在使用这个函数后返回的值就是
  return之后的值，如果return后面没有值那么就不会有返回值的产生

函数的定义与调用

1.函数就像我们的逻辑一样，必须是要先定义好才可以从下方调用这个函数方法，而不可以在上方就想要先使用最后再在下
方再去补
2.函数首先要给他进行标注定义使用关键字（def）+函数名+括号（）这样才是一个完整的定义函数的第一部的方法
3.在你真正给函数写核心内容时可以先使用pass来定义你还没想好的功能，如果上方函数第一步定义好的话你所编写
的内容只要符合语法那么你写出的无论是什么都不会报错，因为代码不会先直接执行函数，如果下方有往出调用的话
才会执行你这个函数但是如果没写好那么到这个时候才会报错
"""在上方有函数时你在下方遇到有函数的话那么先执行函数，因为函数的执行有限级最高"""

函数的分类

1.内置函数
	内置函数就是我们python中自带的一些常用函数，在你打开python解释器时系统就会帮你自动运行一遍，
  方便你使用例如int就是我们经常使用的一个内置函数，系统已经帮我们设置好这个函数直接调用即可。
2.自定义函数
	我们在使用中如果遇到需要在不同地方使用的重复性代码那么我们就可以将这个代码写成一个自定义函数，
方便我们在下方直接调用这个代码而不用一次一次去重复写这个代码
3.函数的返回值
	return控制这个函数的返回值，就是返回被调用函数所返回的值，但是这个东西可有可无
4.如果我们在没有return时下方需要返回值那么就会直接跳none，如果上方函数只有return后面没有东西，那么
返回的也是none，return后面跟了东西那么跟的是什么返回的就是什么，如果跟的是一个变量名那么返回的则是这个
变量名的数值

函数参数的概念

1.参数的概念
	1.1函数一般分为编写函数时设置的形参和在下方调用时用来调用的实参两种
   1.2形式参数在设置函数时，在括号中填入的参数叫做形式参数，有点像我们字典中的k值，但是没有实际意义上
   与他配对的v值
	1.3实际参数在调用函数时，在括号中填入的参数叫做实际参数，就像我们字典中的v值，同样也没有实际
  意义上与它搭配的k值
2.位置参数
	位置参数其实就是将形参和实参都以从左到有的方式按顺序排列好填入的数值叫做位置形参和位置实参
3.关键字实参
	关键字实参就是直接定义好上方形参所需要返回的值，如果全部都是关键字参数并与上方的形参对应那么
  顺序也是可以随便定义的，可以直接索引到自己对应的值，如果不都是关键字参数那么就需要从简单到困难一次按
  照上方形参所需要的顺序进行排序
4.默认值形参
	默认值形参是指在编写函数阶段就将形参直接定义好值，如果下方实参有值那么就替换成实参的值，如果
  没有的话那么就是用默认的形参
5.可变长形参
	可变长形参就是在编写函数阶段如果不知道下方调用的值到底是多少时那么就可以值用，可以无限加下方
  实参，上方形参一概接纳，如过时关键字实参那么就会将接纳的值转为字典格式

标签：总结,函数,第三周,joseph,dict,l1,print,name
来源： https://www.cnblogs.com/joseph-bright/p/16440605.html