Python基础

Python基础

#整型
num_int=123
print(num_int)
print(type(num_int))

#字符型
num_char="123"
print(num_char)
print(type(num_char))

#布尔型
num_bool=True
print(num_bool)
print(type(num_bool))

#数组(列表)：可以是任何元素，整数，字符串，布尔，列表，元组，字典，集合
num_list=[1,2,3]
print(num_list)
print(type(num_list))

#集合：无序的，不可重复的元素的集合
num_set={1,2,3}
print(num_set)
print(type(num_set))

#元组：里面可以放任何元素，整数，字符串，布尔，集合，元组，数组，字典
num_tuple=(1,2,3)
print(num_tuple)
print(type(num_tuple))

#字典
num_dict={1:'one',2:'two',3:'three'}
print(num_dict)
print(type(num_dict))

#f字符串  用于字符串的传值
a1="father"
b1="mother"
print("小红是：{b1},小明是：{a1}")
print(f"小红是：{b1},小明是：{a1}")
#元组法代替f字符串法
print("小红是：",b1,",小明是：",a1)

#转义字符 换行符\n, 制表符\t(就是加空格)
num_str="123\n456\n789"
num_str2='123\t456\t789'
print(num_str)
print(num_str2)

#字符串的比较
str1="123"
print(str1=="456")
print(str1!="456")

#数字的比较
int=123
print(int==123)
print(int>234)
print(int>=234)
print(int<234)
print(int<=234)

#集合的比较
num_set1={1,2,3,4}
print(1 in num_set1)
print(1 not in num_set1)

#数组的比较
num_list1=[1,2,3,4]
print(1 in num_list1)
print(1 not in num_list1)

#元组的比较
num_tuple1=(1,2,3,4)
print(1 in num_tuple1)
print(1 not in num_tuple1)

#字典的比较
num_dict1={'one':1,"two":2,"three":3}
print(1 in num_dict1.values())      #字典的.values()方法
print(1 not in num_dict1.values())  #字典的.values()方法

#and    or
T=True
F=False
print(T and F)
print(T or F)

#判断语句
bool1=False
bool2=False
bool3=False
if bool1:
    print("当bool1为True时，这一行执行")
elif bool2:
    print("否则当bool2为True时，这一行执行")
elif bool3:
    print("否则当bool3为True时，这一行执行")
else:
    print("否则这一行执行")

int_1=123
float_1=123.0
str_1="123"
bool_1=True
#转换为字符型用str函数
print(str(int_1))
print(str(float_1))
print(str(bool_1))
print(type(str(int_1)))
print((type(str(float_1))))
print(type(str(bool_1)))
#同理：转换为整型用int函数
#同理：转换为浮点型用float函数
#同理：转换为布尔型用bool函数

#元组拆分法:极速赋值
a,b,c=1,2,3
print(a,b,c)
#元组拆分法：极速交换变量
c,d=4,5
d,c=c,d
print(c,d)
#元组拆分法：只要前两个元素
tuple2=1,2,3,4,5,6,7,8,9
e,f,*r=tuple2
print(e)
print(f)
print(*r)

#访问列表中的元素，列表的索引从0开始,从右向左索引从-1开始
list2=[1,'1',True,(1,2,3),[1,2,3],{1,2,3},{"one":1,"two":2,"three":3}]
print(list2[0])
print(list2[-1])
#对列表中的元素进行修改
list2[0]=2
print(list2)
#切片：访问列表
print(list2[1:])
print(list2[:-1])
print(list2[:])
#间隔几个元素采样一次
print(list2[::2])
#列表中添加元素
print(list2+['a','b','c'])
#复制n倍的自己
print(list2*2)

#字典中元素的值可以是任意变量,索引一般是数字或者字符串，一般都是字符串
dict12={0:1,1:"1",2:True,3:(1,2,3),4:[1,2,3],5:{1,2,3},6:{"one":1,"two":2,"three":3}}
#字典的添加
dict12['添加键1']='添加值1'
dict12['添加键2']='添加值2'
print(dict12)
#字典的删除
del dict12['添加键1']
print(dict12)

#循环遍历列表 for循环
list3=['清华大学','北京大学','厦门大学']
for i in list3:
    out=f"{i}是一个名牌大学"
    print(out)
print("循环结束")

#循环遍历字典:既可以遍历键，也可以遍历值，也可以遍历键值对  for循环
dict11={0:1,1:"1",2:True,3:(1,2,3),4:[1,2,3],5:{1,2,3},6:{"one":1,"two":2,"three":3}}
for k in dict11.keys():
    print(f"遍历键{k}")
print("循环遍历键结束")
for v in dict11.values():
    print(f"遍历值{v}")
print("循环遍历值结束")
for k,v in dict11.items():
    print(f"遍历键值对，键是{k}，值是{v}")
print("循环遍历键值对结束")

#while循环
a=1
while a<=5:
    print(f"a循环{a}次")
    a+=1
print("while循环结束")

#continue和break
#break可用于while循环和for循环，结束循环
a1=1
while True:
    if a1>5:
        break
    print(a1)
    a1+=1
#continue可用于while循环和for循环，跳出当前循环进行下一次循环
a2=1
while a2<5:
    a2 += 1
    if a2==3:
        continue
    print(a2)

#循环求平方
value=[]
for i in [1,2,3,4,5]:
    value=value+[i**2]
print(value)
#列表推导式求平方
value=[i**2 for i in [1,2,3,4,5]]
print(value)

#加入if判断语句 循环求平方
value1=[]
for i in [1,2,3,4,5]:
    if i <=4:
        value1=value1+[i**2]
print(value1)

#加入if判断语句  列表推导式求平方
value1=[i**2 for i in [1,2,3,4,5] if i <=4]
print(value1)

#转化为集合set函数
#转化为元组tuple函数
#转化为列表list函数
#转化为字典dict函数
set_1={1,2,3}
tuple_1=(1,2,3)
list_1=[1,2,3]
dict_1={"one":1,"two":2,"three":3}
#转为集合
print(set(tuple_1))
print(type(set(tuple_1)))
#转为元组
print(tuple(set_1))
print(type(tuple(set_1)))
#转为列表
print(list(set_1))
print(type(list(list_1)))
#转为字典  需要搭配zip函数一起使用
print(dict(zip({"one","two","three"},dict_1)))
print(type(dict(zip({"one","two","three"},dict_1))))

#定义一个简单的函数：吞吐各个类型的变量
def my_def(i):
    return i
#整型
int_2=123
print(my_def(int_2))
print(type(my_def(int_2)))
#字符串
char_2='123'
print(my_def(char_2))
print(type(my_def(char_2)))
#布尔型
bool_2=True
print(my_def(bool_2))
print(type(my_def(bool_2)))
#集合
set_2={1,2,3}
print(my_def(set_2))
print(type(my_def(set_2)))
#元组
tuple_2=(1,2,3)
print(tuple_2)
print(type(tuple_2))
#列表
list_2=[1,2,3]
print(list_2)
print(type(list_2))
#字典
dict_2={"one":1,"two":2,"three":3}
print(dict_2)
print(type(dict_2))

#吞吐多个变量
def my_def1(a,b):
    '''加法和乘法'''
    return a+b,a*b
print(my_def1(1,2))

#吞吐任意数量的参数
def my_def2(*r):
    return r
print(my_def2("hello","world","清华大学","北京大学"))

#吞吐多个普通参数，并附带一个任意数量的参数
def my_def3(c,*d):
    return c,d
m,n=my_def3("1","2","3","4",'5')
print(f"{m}不等于{n}")

#吞吐多个普通参数，并附带一个键值对参数
def my_def4(in1,in2,**in3):
    in3["one"]=in1
    in3["two"]=in2
    return in3
out=my_def4(1,2)
print(out)
#额外补充法
out1=my_def4(1,2,three=3,four=4)
print(out1)

#函数的关键字调用
def my_def5(school,major,evaluate):
    out_1=f"{school}的{major}非常{evaluate}"
    return out_1
#顺序调用
print(my_def5("清华大学","软件工程","牛逼"))
#关键词调用
print(my_def5("清华大学",evaluate="牛逼",major="软件工程"))

#给某些参数一个默认值
def my_def6(school,major,evaluate="牛逼"):
    out_2=f"{school}的{major}非常{evaluate}"
    return out_2
print(my_def6("清华大学","软件工程"))
print(my_def6("清华大学","计算机科学与技术"))
#打破默认值
print(my_def6("清华大学","医学",evaluate="哈拉扫"))

#类：名称的首字母必须大写
#每个类都必须包含__init__方法
class MyClass:
    '''做加法和乘法的类'''
    def __init__(self,a,b):
        '''a和b是公共变量，也是self属性'''
        self.a=a
        self.b=b
    def add(self):
        '''加法'''
        return self.a+self.b
    def sub(self):
        '''乘法'''
        return self.a*self.b

#创建一个类的实例
DL=MyClass(2,3)
#访问属性
print(DL.a,DL.b)
#调用方法
print(DL.add())
print(DL.sub())

#属性的默认值
#默认值不用写进__init__里面
class MyClass1:
    '''一个真正的Man'''
    def __init__(self,name,age):
        self.name=name
        self.age=age
        self.gender="Man"

    def zwjs(self):
        print(f"我叫{self.name},我今年{self.age}岁,我是{self.gender}")

DL1=MyClass1("张三",18)
DL1.zwjs()
#修改默认值
DL1.gender="boy"
print(DL1.gender)

print("继承开始")
#继承
class Father:
    '''这是父类'''
    def __init__(self,a,b):
        self.a=a
        self.b=b
    def add(self):
        return self.a+self.b
    def mul(self):
        return self.a*self.b

class Child(Father):
    '''这是子类'''
    def __init__(self,a,b):
        super().__init__(a,b)  #继承父类

    def sub(self):
        return self.a-self.b
    def div(self):
        return self.a/self.b

#初始化一个子类
Demo=Child(3,5)
print(Demo.add())
print(Demo.mul())
print(Demo.sub())
print(Demo.div())

print("继承结束")
print("掠夺开始")

#掠夺
#被掠夺的类
class MyClass2:
    def __init__(self,a,b):
        self.a=a
        self.b=b
    def add(self):
        return self.a+self.b
    def sub(self):
        return self.a-self.b
#掠夺者
class Ldz:
    def __init__(self,c,d):
        self.c=c
        self.d=d
        self.cnt=MyClass2(c,d) #掠夺其他类的方法
    def mul(self):
        return self.c*self.d
    def div(self):
        return self.c/self.d

demo=Ldz(2,4)
print(demo.cnt.add())
print(demo.cnt.sub())
print(demo.mul())
print(demo.div())

print("掠夺结束")