kiss原则

Keep It Simple & Stupid

数据类型

bool

number 数字

string 字符串

tuple 元组

list 列表

set 集合

dictionary 字典

1、Python可以同时为多个变量赋值，如a, b = 1, 2。
2、一个变量可以通过赋值指向不同类型的对象。
3、数值的除法包含两个运算符：**/** 返回一个浮点数，**//** 返回一个整数。
4、在混合计算时，Python会把整型转换成为浮点数。

bool

引用：bool()

1 2	True==1 False==0

逻辑运算符

number

可以使用del语句删除一些对象引用。

1 2	var1 = 1 del var

a=1121213545343543/45343545343#24727.08159148461
b=6/2#3.0
c=0.1+0.2#0.30000000000000004
print(a)
print(b)
print(c)
i=0
while i<1:#浮点数并不是百分百精确的 
    i=i+0.1
    print(i)
'''
0.1
0.2
0.30000000000000004
0.4
0.5
0.6
0.7
0.7999999999999999
0.8999999999999999
0.9999999999999999
1.0999999999999999
'''
import decimal
f=decimal.Decimal("0.1")
ff=decimal.Decimal("0.2")
print(f+ff)#0.3
print(0.00005)#5e-05
d=i+2j
print(d.real)
print(d.imag)
'''
1.0999999999999999
2.0
'''

print(4/2)
print(4//2) #整除并向下取整-3/2=-2
#地板除的结果乘以除数+取余数等于被除数
print(divmod(3,2))
#同时求出地板除和余数
print(abs(-520))#取绝对值
print(abs(1+2j))#abs还能对复数取模
print(int('520'))
print(int(3.14))#haiyoufloat(),complex(),
#pow(2,3)=2**3
#pow(2,3,5)=2**3%5

List列表

用[ ]定义

几乎任何数据类型都能往里怼

假设一个序列为temp

可通过temp[[0],temp[1],访问其中的第一，第二个元素

temp[-1]访问最后一个元素

temp[0:3],范围索引

当一个序列很长时

可以令length=len(temp)

增

temp.append(内容)

可用于添加单个元素，添加到末尾

temp.extend(,,,)添加多个多个元素，添加到末尾

利用切片也能做到一样的效果

temp.insert(x,y)

可以在下标为x处插入y

temp.insert(len(temp),x)

在末尾处插入x

删

temp.remove(x) 用于删除特定内容的元素

x便被删除了

如果列表中存在多个匹配的元素，那么它只会删除第一个

如果指定的元素不存在，那么程序就会报错

temp.pop(x) 用于删除特定位置的元素

下标为x的元素则会被删除

temp.clear() 便可清空序列中的元素

替

排序与反转

temp.sort 从小到大排序

先sort再temp.reserve能做到从大到小

或者直接

temp.sort(reserve=True)

查找

temp.count(3) 能查找元素3出现的次数

temp.index(3) 能查出元素3的下标如果有多个相同的元素，会返回第一个元素

index的另一个功能

能指定查找的范围

temp.index(x,start,end)

拷贝

temp1=temp.copy()

第一眼觉得好像直接temp1=temp就可以

但是效果不一样，等于说你把temp2添加了个名字，没有创建新列表

利用切片能做到一样的copy效果

temp1=temp[:]

这个操作选中了temp中的所有元素，创建了temp1这个列表

加法和乘法

嵌套列表

也就是二维列表

假设有一二维数组temp，

temp[0] 便可访问数组的第一行，

今天也解开了一个疑惑

原来编程语言中的坐标是这样的

也可以通过循环建立二维数组

为啥？？？

is

说明python对于不同对象的存储机制是不一样的

上头那俩a和b不同的原因如下，他的内存结构不同

所以，运用称号所建立的二维数组只是对一维i数组进行了多次引用，改变一个元素，会影响多个元素

通过y来访问的x，数据存于同一内存，更改y的值，x也会改变

深拷贝和浅拷贝

用

.cocy()的是浅拷贝

且改变拷贝的值对原列表无影响

切片拷贝同上，同为浅拷贝

但是浅拷贝只能拷贝外层对象，在处理嵌套列表时改变拷贝的值对原列表有影响

想要实现深拷贝

1	import copy

y=copy.copy(x) 也是浅拷贝

y=copy.deepcopy(x) 就是浅拷贝

列表推导式

用推导式创建嵌套

列表推导式后面可以加条件

先执行for语句，在执行判断语句，最后执行表达式

降维打击 (乐)

1
2
3

matrix=[[1,2,3],[4,5,6],[7,8,9]]
flatten=[col for row in matrix for col in row]
flatten=[1,2,3,4,5,6,7,8,9]

先外后内

字符串

判断回文数

1	"是回文数" if x==x[::-1] else "不是回文数"

大小写字母换来换去

x.capitalize() 将整个字符串首字母大写，其他字母变为小写

并没有改变字符串，只是按照规则生成一个新的字符串

x.casefold() 全变小写不只可以处理英语

x.title() 将每个单词的首字母大写，其他字母变为小写

x.swapcase() 大小写反转

x.upper() 全变大写

x.lower() 全变小写只能处理英文

左中右对齐

不想学哈哈

查找

count(sub[,start[,end]])

x.find 从左往右找

x.rfind 从右往左找

x.index

x.rindex

这两个与上头那两个不同的是，当未定位到目标字符串时，那么处理方式是不一样的，find找不到的话会返回-1，index找不到会返回红字异常

替换

有两种缩进方式

tab和空格

一片代码中这两种缩进方式不能共存

拿到代码后，要用替换把tab替换成空格

1	y=x.expandtabs(4) #参数是指一个tab代表几个空格

判断

x.startwith(y)

判断字符串x中y是否位于字符串首，位于则返回True

x.startwith(y,num1,num2)

可以指定范围

可以传入元组

x.endwith则相反

x.isalpha()

判断x是否全是字符

x.space

判断x是不是空白字符串

空格

tab

x.isprintable()

是否可打印

\n 不可打印

x.isdecimal()

不能判断二的二次方

x.isdigit()

x.isnumeric()

只有它能判断罗马数字

中文数字

三个都是判断是否是数字的

x.alnum()

上面那三个有一个是true，则返回true

x.isidentifier()

判断是否是一个合法的标识符

拆分与拼接

拆单个

partition()

rparttion()

拆多次

split()

rsplit()

不加参数时，默认有空格才分割

有两个参数，第一个参数是指定分隔符，第二个参数是指定分割次数，默认为-1，全割掉

splitlines()

按行进行分割，以列表的形式返回

有一个参数，True或者False

默认为False，改成True时列表中会包含换行符

格式化字符串

花括号里可以加参数，一个参数可以使用多次，默认是从多网友依次对应

关键词参数不用管顺序

想输出花括号怎么办

加上正负号或千位分隔符

{:.2f}.format(3.1415)
3.14
{:.2g}.format(3,1415)
3.1
{:.6}.format("I love FishC")
'I love'
{:.2}.format(520)
整数会报错

这些适用于整数

序列

包括可变序列列表

和不可变序列元组和字符串

+和*何以用于序列操作

python对象三要素

id，类型，值

可变序列进行操作后id不变，不可变序列进行操作后id也变

is 和 is not 判断对象的id是否相等

in 和not in 是包含运算

del 可用于删除对象

del也可以切片删除序列中的部分元素

函数

列表元组字符串相互转换

list() 转列表

tuple() 转元组

str() 转字符串

min和max

可以把序列作为参数传进去

传出序列中最小或最大的元素

min(x)

max(x)

不能传入空对象

假设y为空对象

min(y,default=”啥也没有”)

就不会报错，取而代之的是输出啥也没有

len和sum

len的极限范围是2的63次方减一

len(x)

sum(x)

sorted 和 reserved

sorted(x) 返回的是从小到大排序的新列表

原来的列表并没有受影响

sort(x) 是直接将x排序

sorted也支持reserve参数

sorted(x,reserve=True)

sorted派字符串时，若首字母一样，则根据第二个字母排，以此类推

sorted还有一个参数key

可以干预排序算法，列表的sort的也是，注意sort只能处理列表，sorted可以接受任何形式的可迭代对象

比较长度

reserved()

Tuple 元组

用( )定义

也可以不加(),用逗号隔开就行

元组的数据不可改，list的可改

Dictionary字典

以{}定义，类似于c的结构体

可改变内容，元素之间以‘，’分隔

在映射数据类型的获取上，字典的效率是要远远快于列表的

特征为冒号和逗号

序列通过位置偏移存取数据

字典通过键

键不能重复

dict函数

用于建立字典

创建字典六种方法

增

从无到有创建一个键的值相同的字典

减

d.pop(‘键’)

返回键对应的值，并删除键

pop不存的的会报错，可用default

d.popitem()

删除最后一个元素

del d[‘键’]

del d 删除整个字典

d.clear()

只删除内容

改

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

记笔记：逐个修改太麻烦了，可以使用update([other])的方法，同时传入多个键值对

查

d.get(‘键’,default=”meiyou”)

a.setdefault(‘jian’,”code”)

视图对象

items() 获取键值对的—-

keys() 获取键的—-

values() 获取值的—-

复制

d.copy()

len(d)

获取键值对的数量

in not in

list(d)

可以把字典转换为列表

iter()

嵌套

Set 集合

以{}定义，元素不可重复

创建

{}

推导式

类型构造器

由于集合是无序的，不能通过下标索引去访问

但是可以应用in 和 not in

将集合打印出来也是一个无序的

特点

唯一性

用集合可以轻松去重

查看去重前后的长度

若不相等

则存在重复的元素

s.isdisjoint(“”)

若有交集则返回False

否则返回True

s.issubset(“”)

s是否是后面那个字符串的子集

若是

则返回True

s.issuperset(“”)

s是否包含后面那个字符串

并集

进行并集操作

s.union({1,2,3})

交集

进行交集操作

s.intersection(“”)

差集

s.difference(“”)

如上集中操作，可进行多参数处理

注意只返回结果

不进行改动

要想改动

add整个添加

update迭代添加

从上到下

子集真子集

真超集超集

并集交集

差集

frozenset

不可变的集合

用update更新

小技巧：
带星号说明支持多个参数

删除

s.remove(“”)

删除不存在的元素会报错

s.discard(“”)

s.pop()

随机弹出

哈希

大多数不可变的对象都是可哈希的

可哈希才能作为字典的键

可变的对象是不可哈希的

条件判断

循环Loop

迭代序列

while else

之前没接触过的就while else

用法如下：

其存在的意义就是可以非常容易的检测到循环的退出状况

如果这个循环没有被break掉，完整的运行了下来，才能出现else后的语句

99乘法表

i=1
while(i<=9):
    j=1
    while j<=i:
        print(j,"*",i,"=",i*j,end=" ")
        j+=1
    print()
    i+=1

素数

for i in range(2,11):
    for j in range(2,i):
        if(i%j==0):
            break
    else:     
        print(i,"是素数")

range

第一种用法默认从零开始，右边是个开区间

第二种用法是左闭右开区间

第三种用法是指定跨度，类比于c，前两种用法是i++，第三种可以指定i每次加多少，step可以为大于零，也可以小于零

后两种的start和stop的大小不绝对，start也可以比start小

函数

继11.6校赛之后，认识到python学的还是远远不够

重学

补漏

传进去的是实参

占坑位的叫形参

函数的返回值

return

同 C语言

参数

位置参数关键字参数

fun(a,b,c)

fun(a=”ni”,b=”shi”,c=”shui”)

上面这两个合法

fun(a=”ni”,”shi”,”shui”)

报错：位置参数必须在关键字参数之前

默认参数

默认参数在定义函数时写入

斜杠左面不能有默认参数

def abc(a,/,b,c):

print(a,b,c)

abc(1,2,3)

1 2 3

abc(a=1,2,3)

error

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

3 2 1

def abc(a,*,b,c):

print(a,b,c)

*处只能使用关键字参数

收集参数

不知道要输入多少参数

def myfunc(*args):

print(“有{}个参数。”.format(len(args)))

print(“第2个参数是：{}”.format(args[1]))

myfunc(“www”,”ddd”)

有2个参数

第2个参数是： ddd

args的本质是什么呢

def myfunc(*args)

print(args)

答案是元组

myfunc(1,2,3,4,5)

(1,2,3,4,5)

收集参数后的其他参数要使用关键字转递，不然都会扔进前面的元组

收集参数也可以将传递进的参数打包成元组

方法即多加一个*

myfunc(**kwargs):

同时，反过来*和**也可以解包元组和字典使其扔进函数

变量

在函数中，局部变量会覆盖重名的全局变量

globaL

再函数内修改全局变量的值

嵌套函数

  def funa():
	  x=520
	  def funb():
	      x=880
	      print("in funb x=",x)
	  funb()
	  print("in funa,x=",x)
>>>funa()
in funb x=880
in funa x=520

nonlocal 改外部函数的值

在内层修改外层

 def funa():
	  x=520
	  def funb():
	      nonlocal x
	      x=880
	      print("in funb x=",x)
	  funb()
	  print("in funa,x=",x)
>>>funa()
in funb x=880
in funa x=880

LEGB规则从左到右级别递减

L local 局部作用域

E enclosed 嵌套函数的外层函数作用域

G global 全局作用域

B build-in

禁止起与内置函数相同名的变量名

闭包

函数只有在定义和调用的时候加括号，作为返回值的时候只写名字就可以了

 def funa():
	  x=880
	  def funb():
	      	  print(x)
	  return funB
<<<funa()
<
<<<funa()()
880

每一次传入参数都会改变函数中x，y的值

装饰器

如何使其调用函数时自动调用timemaster函数

即装饰器

原理是闭包

等效，调用myfunc时将其作为参数塞到timemaster 当中

一个函数可以调用多个装饰器，依次调用，得出结果并输出

@longer(msg=”a”)

def funa():

等同于

funa=longer(msg=”a”)(funa)

lambda函数表达式

麻烦不想听

生成器

保存函数状态的简便方法

生成器无法使用下标索引

函数help

def函数后

“”“

之间写注释

”“”

help ( 函数名)

即可返回自己编写的内容

def times (s:str,n:int) -> str:

冒号后的和->后的是给人看的

提醒调用者输入什么，告诉调用者返回什么

若还想使用默认参数

def times(s:str=”fff”,n:int) ->str:

retrun s*n

高阶函数

将其他函数作为参数输入的函数叫做高阶函数

永久存储

f= open(“fff.txt”,”w”)

即可创建一个文件

f.write(“666”)

f.writelines([“123\n”,”323”])

写入多个字符串

最后

f.close 保存文件

f= open(“fff.txt”,”r+”)

此时即可读取又可写入

f.readable()

True

f.writalbe()

True

f.flush() 不关闭文件保存文件

ps：

w：打开一个文件用于写入。如果文件已存在将对其覆盖。

感觉忘了会出问题

基础语法

print

print 默认输出是换行的。//，如果要实现不换行需要在变量末尾加上 end=””

x="a"
y="b"
# 换行输出
print( x )
print( y )
 
print('---------')
# 不换行输出
print( x, end=" " )
print( y, end=" " )
print()

以上实例执行结果为：

a
b
---------
a b

Python允许你同时为多个变量赋值。例如：

1	a = b = c = 1

也可以为多个对象指定多个变量。例如：

1	a, b, c = 1, 2, "runoob"

random

import random
x=random.getstate()
print(random.randint(1,10))
print(random.randint(1,10))
print(random.randint(1,10))
random.setstate(x)
print(random.randint(1,10))
print(random.randint(1,10))
print(random.randint(1,10))#可以看到两组的随机数是相同的

短路逻辑和运算符优先级

我的理解就是输出了决定了他是true还是false的结果的那个数

优先级从低到高

加减大于比较

比较大于not and or

not>and>or

流程图

字符

len()求字符串长度

kiss原则

数据类型

bool

number

List列表

增

删

替

排序与反转

查找

拷贝

加法和乘法

嵌套列表

is

深拷贝和浅拷贝

列表推导式

字符串

判断回文数

大小写字母换来换去

左中右 对齐

查找

替换

判断

x.startwith(y)

x.endwith则相反

x.isalpha()

x.space

x.isprintable()

x.isdecimal()

x.isdigit()

x.isnumeric()

x.alnum()

x.isidentifier()

拆分与拼接

拆单个

拆多次

格式化字符串

序列

函数

列表元组字符串相互转换

min和max

len和sum

sorted 和 reserved

Tuple 元组

Dictionary字典

dict函数

创建字典六种方法

增

减

改

查

视图对象

items() 获取键值对的—-

keys() 获取键的—-

values() 获取值的—-

复制

len(d)

in not in

list(d)

iter()

嵌套

Set 集合

创建

{}

推导式

类型构造器

特点

s.isdisjoint(“”)

s.issubset(“”)

s.issuperset(“”)

并集

交集

差集

frozenset

删除

s.remove(“”)

s.discard(“”)

s.pop()

哈希

条件判断

左中右对齐

位置参数关键字参数

LEGB规则从左到右级别递减