python基础复习

时隔一年捡起来，通过Python3 基本数据类型 | 菜鸟教程 (runoob.com)速刷

string

str="Runoob"
print(str)
print(str[0:-1])
print(str[1])
print(str*2)
print(str+"Test")
print(r'Ru\\ndad')#不会发生转义前面加上/n

bool

#bool
'''
布尔类型只有两个值：True 和 False。布尔类型可以和其他数据类型进行比较，比如数字、字符串等。在比较时，Python 会将 True 视为 1，False 视为 0。布尔类型可以和逻辑运算符一起使用，包括 and、or 和 not。这些运算符可以用来组合多个布尔表达式，生成一个新的布尔值。布尔类型也可以被转换成其他数据类型，比如整数、浮点数和字符串。在转换时，True 会被转换成 1，False 会被转换成 0。
'''
a=True
b=False
\\#比较
print(2<3)
\\#逻辑
print(a and b)
print(a or b)
print(not a)
\\#类型转换
print(int(a))
print(float(b))#括起来哦
print(str(a))#bool-》string

注意: 在 Python 中，所有非零的数字和非空的字符串、列表、元组等数据类型都被视为 True，只有 0、空字符串、空列表、空元组等被视为 False。因此，在进行布尔类型转换时，需要注意数据类型的真假性。

List

List（列表） 是 Python 中使用最频繁的数据类型。

列表可以完成大多数集合类的数据结构实现。列表中元素的类型可以不相同，它支持数字，字符串甚至可以包含列表（所谓嵌套）。

列表是写在方括号 [] 之间、用逗号分隔开的元素列表。

和字符串一样，列表同样可以被索引和截取，列表被截取后返回一个包含所需元素的新列表。

变量[头下标:尾下标]

#List
list=['adad','dadad',2.33,'dasda']
tinyList=[1312,'2312312']print(list)
print(list[0])
print(list[1:3])
print(list[2:])
print(tinyList*2)#*重复操作
print(list+tinyList)#+为连接操作a=[0,45,5,2,52,2]
a[0]=99
print(a)
a[2:4]=[]#去掉5和2
print(a)
#翻转字符串演示
def reverseWords(input):inputWord=input.split(" ")inputWord=inputWord[-1::-1]output=' '.join(inputWord)return output
if __name__=='__main__':input='hello world'rw=reverseWords(input)print(rw)

元组

元组（tuple）与列表类似，不同之处在于元组的元素不能修改。元组写在小括号 () 里，元素之间用逗号隔开。

元组中的元素类型也可以不相同：

tuple=('abcd',786,'runoob')
tinyTuble=(123,'runoob')print(tuple)
print(tuple[0])
print(tuple[1:3])
print(tuple[2:])
print(tinyTuble*2)
print(tuple+tinyTuble)\\#tuple[1]=0 无法修改元组中的元素

set

集合（set）是由一个或数个形态各异的大小整体组成的，构成集合的事物或对象称作元素或是成员。

基本功能是进行成员关系测试和删除重复元素。

可以使用大括号 { } 或者 set() 函数创建集合，注意：创建一个空集合必须用 set() 而不是 { }，因为 { } 是用来创建一个空字典。

parame = {value01,value02,...}
或者
set(value)

myset={'dasda','hello','baidu'}
print(myset)if 'hello' in myset:print("在集合中")
else:print("不在集合中")a=set('abbcasca')
b=set('alacazam')print(a)
print(a-b)
print(a|b)#并集
print(a&b)
print(a^b)

字典

字典（dictionary）是Python中另一个非常有用的内置数据类型。

列表是有序的对象集合，字典是无序的对象集合。两者之间的区别在于：字典当中的元素是通过键来存取的，而不是通过偏移存取。

字典是一种映射类型，字典用 { } 标识，它是一个无序的 键(key) : 值(value) 的集合。

键(key)必须使用不可变类型。

在同一个字典中，键(key)必须是唯一的。

odict={}
odict['one']="1-真的离谱"
odict[2]="2-芜湖"tinydict={'name':'符传朔','nani':'dasda'}print(tinydict)
print(odict)
print(odict[2])
print(tinydict.keys())
print(tinydict.values())
#构造函数 dict() 可以直接从键值对序列中构建字典如下：
mydict=dict([('runnov',1),('da',2),('taibap',3)])
print(mydict)
mydict.clear();
print(mydict)

注意：

• 1、字典是一种映射类型，它的元素是键值对。
• 2、字典的关键字必须为不可变类型，且不能重复。
• 3、创建空字典使用 { }。

bytes类型

x=bytes("hello",encoding="utf-8")
print(x)
y=b"hello"
print(y)
z=x[1:3]
print(z)
z=x+b"worf"
print(z)
x=b"hello"
if x[0]==ord("h"):print("same")
else:print("different")

f-string

f-string 是 python3.6 之后版本添加的，称之为字面量格式化字符串，是新的格式化字符串的语法。

之前我们习惯用百分号 (%):

name='runoob'
s='hello%s'%name
print(s)

f-string 格式化字符串以 f 开头，后面跟着字符串，字符串中的表达式用大括号 {} 包起来，它会将变量或表达式计算后的值替换进去，实例如下：

w={'name':'runoob','url':'www.runoob.com'}
k=f'{w["name"]}:{w["url"]}'
print(k)

条件控制语句

if

Python中if语句的一般形式如下所示：

if condition_1:statement_block_1
elif condition_2:statement_block_2
else:statement_block_3

Python 中用 elif 代替了 else if，所以if语句的关键字为：if – elif – else

number=7
guess=-1
print("猜数字游戏开始")
while guess!=number:guess=int(input("请输入你猜的数字："))if guess==number:print("恭喜，你猜对了！")elif guess<number:print("猜的数字小了。。。")elif guess>number:print("猜的数字大了。。。")

Match…case

def http_error(status):match status:case 400:return "Bad request"case 404:return "not Found"case 418:return "i'm a teapot"case _:return "someThing wrong with internet"my_status = 400
print(http_error(400))

python推导式

列表推导式

列表推导式格式为：

[表达式 for 变量 in 列表] 
[out_exp_res for out_exp in input_list]或者 [表达式 for 变量 in 列表 if 条件]
[out_exp_res for out_exp in input_list if condition]

• out_exp_res：列表生成元素表达式，可以是有返回值的函数。
• for out_exp in input_list：迭代 input_list 将 out_exp 传入到 out_exp_res 表达式中。
• if condition：条件语句，可以过滤列表中不符合条件的值。

#1.列表推导式
name=['bob','tom','peter']
newnames=[name.upper() for name in name iflen(name)>3]
print(newnames)

字典推导式

字典推导基本格式：

{ key_expr: value_expr for value in collection }或{ key_expr: value_expr for value in collection if condition }

使用字符串及其长度创建字典：

#2.字典推导式
listdemo=['Google','taobao']
newdict={key:len(key) for key in listdemo}
print(newdict)

元组推导式

元组推导式可以利用 range 区间、元组、列表、字典和集合等数据类型，快速生成一个满足指定需求的元组。

元组推导式基本格式：

(expression for item in Sequence )
或
(expression for item in Sequence if conditional )

元组推导式和列表推导式的用法也完全相同，只是元组推导式是用 () 圆括号将各部分括起来，而列表推导式用的是中括号 []，另外元组推导式返回的结果是一个生成器对象。

例如，我们可以使用下面的代码生成一个包含数字 1~9 的元组：

#python推导式
#元组推导式
a=(x for x in range(1,10))
print(tuple(a))

迭代器

list=[1,2,3,4]
it=iter(list)
for x in it:print(x,end=" ")

import syslist=[1,2,3,4]
it=iter(list)while True:try:print(next(it))except StopIteration:sys.exit()

'''
__iter__() 方法返回一个特殊的迭代器对象， 这个迭代器对象实现了 __next__() 方法并通过 StopIteration 异常标识迭代的完成。__next__() 方法（Python 2 里是 next()）会返回下一个迭代器对象。创建一个返回数字的迭代器，初始值为 1，逐步递增 1：
'''
class MyNum:def __iter__(self):self.a=1return selfdef __next__(self):x=self.aself.a+=1return xmyclass=MyNum()
myiter=iter(myclass)print(next(myiter))

class MyNum:def __iter__(self):self.a=1return selfdef __next__(self):if self.a<=20:x=self.aself.a+=1return xelse:raise StopIteration
myclass=MyNum()
myiter=iter(myclass)for x in myiter:print(x)

传递参数

def change(a):print(id(a))a=10print(id(a))a=1
print(id(a))
change(a)

不可变

def changeme(list):list.append([1,2,3,4])print("函数内取值",list)returnmylist=[10,290]
changeme(mylist)
print("函数外取值：",mylist)

可变

面向对象

类

class Student:def __init__(self,name,score):#构造函数self.name=name;self.score=score;def say_score(self):print("{0}的分数是{1}".format(self.name,self.score));s1=Student("zhangsan",11)
print(s1.name,s1.score)
s1.say_score();

默认函数

#默认参数
def printInfo(name,age=37):print("名字",name)print("年龄",age)returnprintInfo(age=31,name="fcs")
print("------------------")
printInfo(name="rub")

不定长函数

#不定长参数
def printinfo(arg1,*var):print("输出：")print(arg1)print(var)print(70,8,5)

def printinfo(arg1,**vartuple):#双*号就是为字典print("输出：")print(arg1)print(vartuple)printinfo(1, a=2,b=3)

Lambda

x= lambda a:a+10
print(x(5))sum=lambda arg1,arg2:arg1+arg2print(sum(10,20))
print(sum(20,20))def myfunc(n):return lambda a:a*n
mydoubler=myfunc(2)
print(mydoubler(11))