python学习笔记一

python笔记

Python input() 函数

函数语法
input([prompt])
参数说明：
prompt: 提示信息
Python3.x 中 input() 函数接受一个标准输入数据，返回为 string 类型。

>>> a = input("input:")#将用户输入的值与左边的变量名进行挂钩
input:123
>>> type(a)
<class 'str'>

第一个游戏

"""用python设计的第一个游戏"""

temp = input("猜数字")
guess = int(temp)

if guess == 8:
    print("恭喜你!")
    print("猜对了！")
else:
    print("猜错了")

print("游戏结束")

交换变量（方式一：c的写法，用中间变量 方式二：python写法更便捷）

注意：字符串使用加法进行拼接，使用乘法进行复制！！！

else中再嵌套

break和continue用在while和for循环中

执行break语句，会使得break语句所属层次的循环提前结束。
执行continue语句，作用是提前结束本次循环，提前进入下一次循环。
continue 语句跳出本次循环，而break跳出整个层次的循环。

/除法

//地板除，取比目标结果小的最大整数，比如3//2=1,-3//2=-2

判断为False的情况

and 和or 遵从短路逻辑思想：从左往右，只有当第一个操作数的值无法确定逻辑运算的结果时，才对第二个操作数进行求值

if条件，基本形式

if 判断条件：
执行语句……
else：
执行语句……

当判断条件为多个值时，可以使用以下形式：由于 python 并不支持 switch 语句，所以多个条件判断，只能用 elif 来实现

if 判断条件1:
执行语句1……
elif 判断条件2:
执行语句2……
elif 判断条件3:
执行语句3……
else:
执行语句4……

for循环

Python for循环可以遍历任何序列的项目，如一个列表或者一个字符串。
语法：
for循环的语法格式如下：

for iterating_var in sequence:
   statements(s)
  eg;for i in range(5,10):----i在5到10中遍历取出来

range(5,10),生成5-10的整数，打印出来的数字含5不含10，左闭右开型

列表

列表是最常用的Python数据类型，它可以作为一个方括号内的逗号分隔值出现。
列表的数据项不需要具有相同的类型
创建一个列表，只要把逗号分隔的不同的数据项使用方括号括起来即可。如下所示：

list1 = ['physics', 'chemistry', 1997, 2000]
list2 = [1, 2, 3, 4, 5 ]
list3 = ["a", "b", "c", "d"]

与字符串的索引一样，列表索引从0开始。列表可以进行截取、组合等。

访问列表中的值

使用下标索引来访问列表中的值，同样你也可以使用方括号的形式截取字符，如下所示：

list1 = ['physics', 'chemistry', 1997, 2000]
list2 = [1, 2, 3, 4, 5, 6, 7 ]
 
print "list1[0]: ", list1[0]
print "list2[1:5]: ", list2[1:5]#和range一样也是左闭右开型，取到1取不到5，也就是下标1-4
以上实例输出结果：

list1[0]:  physics
list2[1:5]:  [2, 3, 4, 5]

切片

[-1]代表获取最后一个值

rhyme[0:6:2]—代表开始、结束、跨度【若0和6代表列表的两端，可以直接省略为rhyme[: : 2]
rhyme[: : -2]倒着按跨度为2的输出，rhyme[: : -1]逆序输出
使用for循环遍历列表，for each in list1:

可以使用append()方法在列表末尾添加元素，如下所示：【每次只能添加一个元素】

可以使用extend()方法在列表末尾添加元素，如下所示：【可以添加一个可迭代对象】

list.insert(待插入位置，待插入元素):

小技巧：若位置为0则插入的位置永远是开头，若位置为len(s)则插入的位置永远为末尾。

list.remove(obj)–通过元素匹配移除

移除列表中某个值的第一个匹配项，若匹配项不存在，程序则会报错

list.pop(index)–通过下标匹配移除

list.pop(2)

list.clear()–清空列表

改 注意：列表是可变的，而字符串是不可变的

通过赋值操作将灭霸更改为钢铁侠
通过切片操作，替换后面的多个数据

list.sort(cmp=None, key=None, reverse=False)

对原列表进行排序

list.reverse()–反向列表中元素

list.count(obj)–统计某个元素在列表中出现的次数

list.index(obj)–从列表中找出某个值第一个匹配项的索引位置

list.index(x,start,end)–指定查找的开始和结束位置

list.copy()–拷贝一个列表

list.copy()等价于list[:]–就是整个列表【python中称为浅拷贝】

列表的加法–也就是拼接

列表的乘法法–也就是重复，乘3，即将列表中的元素重复3次

嵌套列表–列表中再嵌入列表

访问嵌套列表–通过两层for循环访问

matrix[0]–是访问第一行，当只有一个索引时，是直接访问以行为代表的数据

is函数判断两个变量是否指向同一个对象

字符串是不可变的，因此在内存中只需要开辟一个内存
列表是可变的，因此需要在内存中开辟两个位置进行存储

python的赋值操作，其实是将一个变量的引用传递给另一个变量，两个变量指向的是同一个内存，因此，一个变量改变，另一个变量也会跟着改变。

将x赋值给y，也就是通过引用让x,y指向同一个内存，修改X中的一个值，y中的数据也会跟着改变。
因此，他们本身就是指向的同一个内存

浅拷贝与深拷贝

深拷贝浅拷贝，“浅”字在这里的意思就是浅浅一层，仅能能拷贝对象的表层，而其子对象，就是直接拿来引用了，所谓深拷贝就是用递归的原理把其子对象也依次拷贝下来，这就是两者的区别。
浅拷贝通过copy的方法或者切片的方法实现。
浅拷贝即是只拷贝对象第一层而不拷贝其子对象。
对于列表的拷贝我们可以使用列表内置的copy方法，当然也可以使用copy模块的copy方法：list.copy()或者copy.copy(x)

copy拷贝的是整个列表，不仅仅是列表的引用，两个列表是独立存在的，修改一个列表的数据，另一个不会跟着改变

切片也是拷贝的整个列表，修改一个列表的数据，另一个也不会跟着改变

如果是嵌套列表，浅拷贝的子对象拷贝的也只是引用，因此一个变量改变，另一个也会跟着改变

copy模块的浅拷贝与深拷贝,深拷贝通过递归的原理将其子对象也依次拷贝下来（无论怎么嵌套子对象，都是相互独立拷贝出来的对象，一个变量改变，另一个都不会变）
拷贝详细解释：https://blog.csdn.net/undefineing/article/details/121821486

列表推导式 --[expression for target in iterable]

i在range(10)中遍历，然后将遍历后的结果赋值给最前面的i,最终结果组成x列表

也可以通过循环的方式实现，但是没有列表推导式更方便

字符串乘法是重复

取第二列的元素：通过for循环取出矩阵中的每一行，row遍历行，然后row[1]取出每一行的第二个元素。

row_2 = matrix[i][i] for i in range(len(matrix))]
[1, 5, 9]

取对角线的元素，len(matrix)，矩阵中有3个大元素，因此len(matrix)=3,即range(3)—0,1,2
matrix[i][i] 通过下标获取对角线上的元素

通过列表推导式创建列表

列表推导式筛选 --[expression for target in iterable if condition]

取出0-9的偶数

执行顺序：先执行for循环，然后执行条件表达式，最后再将值赋值给最前面的i

将列表中的由F开头的英文筛选出来

列表推导式筛选嵌套

[expression for target in iterable0

                      for target in iterable1

                      for target in iterable2 ]

将二维列表展开成为一维列表，同样也可以使用循环的方式实现

就相当于是双层循环
_ = [] 注意：使用下划线作为变量名，代表临时的或者无关紧要的变量

列表推导式筛选嵌套 加条件

[expression for target in iterable1 if condition1

                      for target in iterable2 if condition2

                      for target in iterableN if conditionN ]

取出能被0整除和能被3整除的数据

元组（元组和列表里面的数据类型都不需要统一）

元组用小括号表示，或者不用括号也可以
注意：元组是不可以修改的，试图修改元组中的值，比如重新赋值修改是会报错的
列表支持增删改查，元组只能进行查的操作

元组同样可以通过切片的操作，取出某些元素

元组通过count函数，计算数值为3的个数

获取元组下标

元组拼接

元组乘法，重复

元组嵌套，通过逗号实现

只有（520，）加上逗号后的类型，才是元组类型

生成一个元组也称为打包，将元组中的数据分别赋给不同的变量称为解包（列表同样适用）

注意：左边用于接收的变量数量必须与右边的数量一致，否则会报错

通过这种形式，直接将10赋值给x,20赋值给y

元组虽然不可修改，但是元组中的元素是可变的列表时，也是可以修改的

字符串（不可变）

x[: : -1]代表整个列表，跨度为-1,也就是倒着跨度为1的遍历，即反转
x == x[: : -1]—数据正向和反向是相同的

capitalize()–将字符串的第一个字符大写
casefold()–将字符串的字符变成小写（不仅仅针对英语，也可以是其他的语言）
title()–所有单词都是以大写开始，其余字母均为小写
swapcase()–大写转小写，小写转大写
upper()–所有字符变大写
lower()–所有字符变小写


center(5)–居中，当宽度小于字符长度时，原样输出【center(15)–当宽度大于字符长度时，用空格填充并居中输出】
ljust()–左对齐
rjust–右对齐
以上3个都可以通过第二个参数指定填充的数据
zfill()–用0向左填充，适用于做报表


count(sub[,start[,end]])—start,end表示查找的开始和结束范围，不指定默认整个范围


find–从左往右找，返回找到的下标
rfind–从右往左找，返回找到的下标

find()和index()类似，只是找不到时find()返回-1，index()直接报错


string.expandtabs(tabsize=8)
把字符串 string 中的 tab 符号转为空格，tab 符号默认的空格数是 8。也可以指定tab的空格个数

string.replace(str1, str2, num=string.count(str1))
把 string 中的 str1 替换成 str2,如果 num 指定，则替换不超过 num 次.

str.maketrans()–指定转换规则，前后一一对应进行转换，比如：A转成1，F转成6，最后一个参数表示省略，即去掉love
.translate()–按照上面制定的规则进行转换，其中I在转换对照表中没有则不转，有的则进行转，F-6,C-3

以上方法都是用于判断，因此返回的都是布尔类型的值，要么true,要么false


startwith()–判断字符串是否以某个字符开始，支持指定开始和结束位置
endtwith()–判断字符串是否以某个字符结束，支持指定开始和结束位置

可以用元组的方式传入进行匹配，元组中的任何一个元素匹配上，则可以匹配成功

istitle()判断字符串中的每个单词是否首字母大写，其余字母均是小写

issupper()判断字符串中的每个单词是否都是大写
islower()判断字符串中的每个单词是否都是小写

isalpha()判断字符串中是否只是右字母构成，注意是否包含空格的情况

判断一个字符串中是否有空格

isprintable()–判断是否可打印，\n转义字符不可打印，因此为false
string.isdecimal()----如果 string 只包含十进制数字则返回 True 否则返回 False.
string.isdigit()-----如果 string 只包含数字则返回 True 否则返回 False.

isidentifier判断是否是一个合法的Python标识符
标识符中不能有空格，不能以数字开头

iskeyword()----判断是不是python的保留标识符



lstrip()----去除左侧空白，后可以加匹配去掉的参数，即：去掉以wcom任意一个字符开头的字母
rstrip()----去除右侧空白，后可以加匹配去掉的参数，即：去掉以wcom任意一个字符结束的字母
strip()----去除左右两侧的空白，后可以加匹配去掉的参数，即：去掉以wcom任意一个字符开始或结束的字母
注意：wcom是"w",“c”,“o”,“m”，"."拆开后，一个一个的去匹配

removeprefix()—匹配前缀，整个字符串"www.“去匹配
removesuffix()–匹配后缀，同样是按照整个字符串”.com"去匹配


partition()—以指定的字符.进行分割，返回三个元组(从左边开始分割）
中间是指定的分隔符，左侧元素是分隔符左侧的内容，右侧元素是分隔符右侧的内容

rpartition()—以指定的字符.进行分割，返回三个元组(从右边开始分割）

str.split(str=“”, num=string.count(str)).
str – 分隔符，默认为所有的空字符，包括空格、换行(\n)、制表符(\t)等。
num – 分割次数。默认为 -1, 即分隔所有。
string.splitlines([keepends])
按照行(‘\r’, ‘\r\n’, ‘\n’)分隔，返回一个包含各行作为元素的列表，如果参数 keepends 为 False，不包含换行符，如果为 True，则保留换行符。

join()----字符串拼接
注意：用加号同样也可以实现字符串的拼接，但是+号的拼接效率没有join()好

format()----格式化字符串，适用{ }来表示格式化的字段
菜鸟教程format参考https://www.runoob.com/python/att-string-format.html



“{:^}”.format(250)----表示居中，冒号前面代表位置索引
“{:^10}”.format(250)----显示宽度为10，然后250居中
“{1:>10}{0:<10}”.format(520,250)----位置索引的1，代表250右对齐，位置索引的0，代表520左对齐
同样可以使用标签索引，通过指定标签名与format中的数据对应
{0:010}----使用0填充，只对数字有效，在字符串中填充0会报错【也可以写为{:0=10}】
{1:%>10}----使用%填充，1代表format中的第二个数据，>右对齐，显示宽度为10


在正数前面加+，负数前面加-

使用逗号和下划线作为千位数分割符


报错，因为精度选项不允许应用在整型上


加上#可以在前缀0b,0o.0x显示是什么进制

语法糖，不改变功能，但是使用可以更简洁
列表、元组、字符串共同点：【统称为序列】–列表是可变序列，元组和字符串是不可变序列
1、都可以通过索引获取每一个元素
2、第一个元素的索引值都是0
3、都可以通过切片的方法获取一个范围

+拼接，*重复

列表重复后，唯一标志id不会改变，只是对象中的元素增多了而已

元组重复后，唯一标志id会改变
is和is not–判断是否为同一个对象
用于检测两个对象的id值是否相同，从而判断是否为同一个对象，也称同一性运算符

字符串不可变，开辟的是同一个内存空间存放，因此为true
列表是可变的，因此，需要开辟不同的空间存放，为false
in和not in–判断是否包含

del–用于删除一个或者多个指定的对象

删除X和Y

删除指定的[1：4]元素，也可以通过切片的方式实现

步长为2的删除元素，删除1，3，5

通过clear()或者del y[:]清空列表，如果直接del y是将整个列表斩草除根

将字符串和元组转换为列表

将字符串和列表转换为元组

将元组和列表转换为字符串，只是在原来的基础上添加一个引号，代表字符串

min()----返回最小的值
max()----返回最大的值

若可迭代对象为空的，则会报错
通过设置空值时的默认数据，避免报错

直接传入参数比较
sum----计算求和

sorted()

sorted()函数返回的是一个全新的列表，原始的列表不会改变
sort()函数是在原始列表的基础上进行排序更改

reverse=true:代表倒着排序
字符串排序是按照ASCII进行比较的，如果第一个字符相同，则对比第二个字符
key=len,干扰排序的方式，通过比较字符串的长度进行排序
注意：sorted函数可以处理任何类型的序列，sort方法只能处理列表

注意：reversed函数可以处理任何类型的序列，reverse方法只能处理列表
reverse()返回的是反转后的列表，reversed()函数可以返回一个逆序序列的迭代器(用于遍历该逆序序列)
也就是说，在经过reversed()的作用之后，返回的是一个把序列值经过反转之后的迭代器，所以需要通过遍历，或者List或者next()等方法获取作用后的值

al()函数是判断是否所有元素都为真，any()函数是判断是否存在一个元素为真


元素序号默认从0开始，也可以指定元素序号开始的数值


x,y,z三个列表的长度是一样的

若长度不一致，以最短的那个为准，多余的元素直接丢掉

可以通过itertools模块中的zip_longest,保留最长的那个字符串的数据，没有的数据自动填充为None


map(指定函数，可迭代对象）
ord用于计算每个字符的ASCII值，第一个参数是指定一个函数，第二个参数是对象—对提供的对象通过函数进行加工

pow计算次方，也就是计算2的5次方，3的2次方以及10的3次方。
和pow(2,5)的计算结果等价

比较大小是对应位置进行比较，最后一个多的8就直接扔掉
第一次比较：1，2，0
第二次比较：3，2，3
第三次比较：5，2，9

map()是返回计算结果的迭代器
filter()是返回计算结果为真的迭代器

第一的参数是用于过滤的函数，第二个参数是待过滤的可迭代对象
将FishC中的小写字母筛选出来，当islower为真时，数据才进行返回
迭代器和可迭代对象
一个迭代器肯定是一个可迭代对象（列表、元组、字符串都是可迭代对象）
区别：
可迭代对象可以重复使用，迭代器则是一次性的

map()函数返回的就是迭代器，只能操作一次，再操作则为空

将可迭代对象通过iter()函数转换为一次性操作的迭代器

next()函数，专门针对迭代器，逐个将迭代器中的元素提取出来，当迭代器中没有元素了，则会报错。

next()中加入第二个参数，当迭代器中的元素都被取出来后，则显示第二个参数的值，不会报错

字典

字典是Python中唯一实现映射关系的内置类型
----如果没有真正的努力奋斗过，就不要觉得自己不行！！！（加油）

外用大括号，然后用冒号分开键：值是字典的结构，如果只有大括号，没有冒号，则是集合的类型
字典通过键获取对应的值，不能使用切片的操作获取值


通过给不存在的键添加值，为字典中创建新的键值对

创建字典

方法一：直接使用大括号和冒号创建
方法二：使用dict()函数创建，不能在键上加引号，键与值用等号连接
方法三：使用dict()加列表的形式，每个键值对用元组包裹
方法四：将方法一作为参数传递给dict()
方法五：混合写法
方法六：通过zip()函数创建

Python中对象包含的三个基本要素
分别是：id(身份标识)、type(数据类型)和value(值)
1.is和==两者都是对对象的比较和判断。

2.is 用于判断两个变量引用对象是否为同一个， == 用于判断引用变量的值是否相等。

3.is也被叫做同一性运算符，这个运算符比较判断的是对象间的唯一身份标识，也就是id是否相同。

增加

使用iterable参数指定的可迭代对象来创建一个新的字典，并将所有的值初始化为values参数指定的值

字符串是一个字符一个字符的进行赋值，适用于创建一个初始值都相同的字典，用于快速初始化字典

修改

给键重新赋值就可以修改了，如果在字典中找不到重新赋值的键，就会变成新增一个键值对

序列和字典的区别：

序列中的元素可以重复，字典中的键值对，不会存在重复的键，重复了就会用新的值去覆盖旧的值

删除

pop(键)—返回删除的键所对应的值，再看字典中已经没有了s
pop一个不存在的键会抛出异常，若不想抛出异常，则在后面添加异常后的输出

popitems()----删除最后一个加入字典的键值对，返回删除的键值对

del也可以删除指定的关键字元素，后面若直接跟字典名的话，则直接删除整个字典，已经不存在字典d了，因此会报错

clear()可以清空字典中的元素，不会斩草除根，直接删除整个字典，因此不会报错，显示空字典

修改（同时修个多个键值对）

update可以传入多个键值对，一个字典，或者传入一个包含键值对的可迭代对象

查找

如果查找的键不在字典中（小写c不存在），则会报错
直接查找，如果键不存在就会报错，可能被用户认为体验不佳，所以可以用get(key[,default]))


get函数查找，可以指定找不到键时的默认返回内容

setdefault 用于查找键是否存在字典中，如果在，则返回其对应的值，如果不在，则指定新的值
d.get() 指定找不到键的时候返回的值，而d.setdefault()是在找不到这个键的时候把指定的新值插入到字典里

大写C存在，则返回其对应的值67，小写的c不存在，则插入指定的新值

这三个方法分别用于获取字典的键值对，键以及值的视图对象。item键值对，key键，values值

浅拷贝copy()

len()----获取键值对的数量
in和not in 判断是否存在字典中

list()----将字典转换为列表，形成由键组成的列表

iter是将字典中的键构成一个迭代器，通过迭代器获取字典中的键

d.reversed()----将字典的数据倒着排列

嵌套

字典中嵌套字典，获取值的话就需要通过两次键定位，才能获取到内部的值

字典中嵌套列表，获取值的话，外层的字典通过键获取，内层的列表通过索引获取

字典推导式

从item()中获取键和值，然后再调换？？？

加上筛选条件，只有大于100的才进行后续的操作

求出FishC的每一个编码值

注意字典中没有重复的键，如果重复循环赋值会以最后一个赋的值为准

集合

集合中所有元素都是独一无二，并且无序的！！！
创建集合

方法一：直接使用大括号创建
方法二：集合推导式，通过for将遍历后的结果传到s,传入的时FishC，后面的顺序变为’h’,‘i’,‘F’,‘C’,‘s’，体现集合的无序性
方法三：类型构造器，通过set()创建集合

注意：集合的无序性表明集合不能使用下标索引的方式进行访问，会报错

可以使用in 和not in 判断某个元素是否存在集合中

可以使用for循环访问集合中的元素，访问出来也是无序的
注意：集合的唯一性，可以利用集合实现去重的操作

将重复的1去掉了

可以通过判断列表和集合的长度是否相同，来判断是否有重复的元素，有重复元素长度会不同，反之则相同
copy()----实现集合的浅拷贝

isdisjoint()判断两个集合间是否有交集，isdisjoint是不相关，没有交集时为true，有交集时则为false

参数可以使用set(“JAVA”)，也可以直接使用"JAVA"


issubset()—判断一个集合是否是另一个集合的子集
issupperset()----判断一个集合是否是另一个集合的超集

union()----求两个集合的并集
itersection()----求两个集合的交集
differerce()----求两个集合的差集，返回的是s集合中去除交集后的剩余元素
以上函数都可以支持多参数

差集是只返回A集合中减去交集后所剩余的元素，对称差集是返回A集合和B集合两个集合减去交集后所剩余的元素。

symmetric_difference()----求两个集合的对称差集

使用符号进行操作
小于等于<=:子集
小于<:真子集
大于等于>=:超集
大于>:真超集
|：并集
&：交集
减号-：差集
^对称差集
注意：使用运算符进行操作，符号的两边必须是集合类型，否则就会报错

左边是集合，右边是字符串，就报错了。使用运算符，两边都必须是集合
集合分为可变set()和不可变frozenset()对象

使用others参数指定的值来更新集合

参数中写的others，有个s就代表支持多个参数的，若是other则只支持一个参数

由于集合不可重复，所以两个1也只会添加1个，字符串“23”作为“2”，“3”两个单独的字符插入的，且无序的

frozenset()不可改变，对他进行改变会报错。

使用交集、差集和对称差集来更新集合，（没有update后缀的只是返回计算结果，集合本身没有改变，有update后缀的会更新改变集合本身）
并集的update方法是使用得最多的，因此直接命名为update方法

往集合中添加数据

注意：使用update向集合中添加元素，是迭代获取每个字符添加的，一个字符一个字符的添加
使用add()向集合中添加元素时，是获取的整个字符串添加的

删除集合中的元素


区别：若删除的元素不存在，remove()方法会抛出异常，discard()方法会静默处理
删除还可以使用pop()方法，用于随机从集合中弹出一个元素

clear():用于清空集合

可哈希

可哈希：哈希值在其整个生命周期中保持不变
hasg(object)-----通过哈希函数获取一个对象的哈希值

1、对整数进行哈希，哈希值是其本身
2、只要两个对象的值是相等的，一个整数，一个浮点数，他们的哈希值也是相等的

python中大多数不可变对象是可哈希的，而可变对象则是不可哈希的
字符串和元组都是不可变对象，可以计算其哈希值。列表是可变对象，不能计算其哈希值，因此会报错。

只有不可变的元素才能作为字典的键和值，以及集合的元素，否则会报错

集合是可变的容器，可变的数据是不可哈希的，因此不能作为集合的元素，会报错

使用frozenset()使得内层集合成为不可变的元素，就不会报错了
嵌套集合用冰山美人，frozen