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 if
          len(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 sys

list=[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=1
        return self
    def __next__(self):
        x=self.a
        self.a+=1
        return x

myclass=MyNum()
myiter=iter(myclass)

print(next(myiter))

class MyNum:
    def __iter__(self):
        self.a=1
        return self
    def __next__(self):
        if self.a<=20:
            x=self.a
            self.a+=1
            return x
        else:
            raise StopIteration
myclass=MyNum()
myiter=iter(myclass)

for x in myiter:
    print(x)

传递参数

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

a=1
print(id(a))
change(a)

不可变

def changeme(list):
    list.append([1,2,3,4])
    print("函数内取值",list)
    return

mylist=[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)
    return

printInfo(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+arg2

print(sum(10,20))
print(sum(20,20))

def myfunc(n):
    return lambda a:a*n
mydoubler=myfunc(2)
print(mydoubler(11))