【Python快速一遍过-免费持续更新】

小白入门请看我另一篇文章，python零基础入门，建议跟着把代码至少敲上3遍

1 列表

liebiao=[1,1,1,1,1,1,1,1,1,1]
print(liebiao)
liebiao[1]=2#修改列表值
print(liebiao)
liebiao.append(99)#方法append（），只在列表末尾添加一个字符串元素
print(liebiao)
liebiao.insert(-1,98)#可在列表的任何位置添加新元素，需要指定新元素的索引和值
print(liebiao)
del liebiao[-1]#根据索引删除列表值
print(liebiao)
print(liebiao.pop(-1))#根据索引删除列表值，并接到删除的值
print(liebiao)
liebiao.remove(1)#根据值本身从列表中删除值
print(liebiao)
liebiao1=liebiao[:3]#切片，从头切到尾，相当于复制列表1的内容给列表2
print(liebiao1)
print(liebiao1.sort())#永久按字母顺序排序
print(liebiao1.sort(reverse=True))#永久按字母顺序倒序排序
print(sorted(liebiao))#临时按字母顺序排序
print(sorted(liebiao, reverse=True))#临时按字母顺序倒序
liebiao1.reverse()#永久倒序排序
print(liebiao1)
print(len(liebiao1))#列表长度
liebiao2=list(range(1,9))#range左闭右开区间
print(liebiao2)
max(liebiao2)
min(liebiao2)
sum(liebiao2)
for num in liebiao2:#遍历列表
    print(num)
liebiao3=[a for a in range(1,9)]#列表解析
print(liebiao3)
print(liebiao3[1:3])#使用索引进行切片，左闭右开

2 元组

# coding=utf-8

print("元组")
'''创建元组的三种形式'''
yuanzu1=(1,2,3,4,5,6)#这是一个元组，元组是不可变的。
yuanzu2=1,2,3,2,2,
yuanzu3=(1,2,3,)

yuanzu1=(10,20)#元组虽然不可变，但能重新赋值。

'''元组可以进行切片跟列表一样使用，只是不能修改值而已'''
yuanzu4=(1,"nihao",[11,22,33])
print(yuanzu4[2][0])#调用11这个值，它的索引是【2】【0】，索引可以为-的

'''元组中可变要素的内容可以变更'''
yuanzu4[2][0]=100
print(yuanzu4)

'''元组可用+*运算符'''
print(yuanzu2+yuanzu3)#用+运算符合并两个元组，串联，临时的
print(yuanzu2*2)#用*运算符,临时的

del yuanzu1 #删除整个元组

'''元组的两个方法'''
print(yuanzu2.count(2))#返回值为2的总个数。
print(yuanzu2.index(2))#返回值等于2的第一个索引

'''用in 和not in 来判断某个值是否在元组中'''
print(1 in yuanzu2)
print(1 not in yuanzu2)

3 字典

# coding=utf-8
print("定义字典")
zidian1={}#空字典
zidian2={1:'apple',2:'ball'}#带有整数键的字典
zidian3={1:'nihao',2:[2,3]}#混合字典
zidian4=dict({1:'apple',2:'ball'})#使用内置函数dict()创建字典

print(zidian2[1])#通过键调用字典中的值
zidian1["名字"]="nini"#添加键值对，[]中为键，=后为值，组成新的键值对
zidian1["sex"]="女"
zidian1["名字"]="wowo"#根据键修改值
# name1=zidian1.pop("名字")#删除并返回值
print(zidian1.popitem())#不接受任何参数，删除并返回最后一个键值对。如果字典为空则引发报错
# del zidian1["名字"]#根据已有的键，删除相对应的键值对




'''遍历键值对'''
zidian5={
    "name":"梨花",
    "name1":"梨花",
    "age":18,
    "sex":"女"
}
for kew,value in sorted(zidian5.items()):#按字母顺序排序遍历键值对
    print(kew+":"+str(value))
for kew in zidian5.keys():#遍历键
    print(kew+str(zidian5[kew]))
for value in zidian5.values():#遍历值，正常遍历，包含重复值
    print(value)
for value in set(zidian5.values()):#遍历值不包含重复值
    print(value)

'''列表中嵌套字典,也就是字典的嵌套'''
liebiao=[]
for zidian in range(10):
    new_zidian={"name":"一号","age":"20","sex":"女"}
    liebiao.append(new_zidian)

'''字典中存储列表'''
love_languages={
    "王一":["c","java","python"],
    "王二":["html"]
}

for name,languages in love_languages.items():
    if "王一" in love_languages:
        if len(languages)>1:
            print(name+"最喜欢的语言是：")
            for language in languages:
                print(language)
        else:
            for language in languages:
                print(name+"最喜欢的语言是："+language)
    elif "王一" not in love_languages:
        print("王二不存在")
    elif "王二" in love_languages:
        if len(languages) > 1:
            print(name + "最喜欢的语言是：")
            for language in languages:
                print(language)
        else:
            for language in languages:
                print(name + "最喜欢的语言是：" + language)
    elif "王一" not in love_languages:
        print("王二不存在")

4 函数

# coding=utf-8
def hanshu1(age=10,name="小狗"):#参数用逗号隔开，
    '''这里写方法体，name="小狗"是给形参设置的默认值
    当调用此函数却不传参时，函数则自动使用默认值,给形参指定默认值时，等号两边不要有空格'''
    print(str(age)+"的"+name+"这是方法体中的一行代码")
print("函数形参。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。")
hanshu1(18)#形参默认值
hanshu1(18,"妮妮")#这是调用函数
hanshu1(18,name="窝窝")#关键字调用函数，就是明确地指出了各个实参对应的形参,=两边没有空格。

print("函数可返回任何类型的值，包括列表和字典等较复杂的数据结构。。。。。。。。。。。。。。。。。。。。。。。")
def fanhui(xing,ming="",waihao=""):
    if waihao:
        return xing+ming+"的外号是："+waihao
    elif ming:
        return xing+ming+"没有外号" #简单返回值
    elif waihao and ming:
        name={"姓:":xing,"名：":ming,"外号：":waihao}#返回字典
        return name
xingming=fanhui("张","话话","小辣椒")#调用函数，输入实参

print("传递列表。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。")
def liebiao(lb):#禁止函数修改列表可以用def liebiao(lb[:])，相当于副本
    for key in lb:
        print(key)
liebiao1=[1,2,3]#定义列表
liebiao(liebiao1)#调用函数

print("传递任意数量的实参。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。")
def renyi(*toppings):
    '''形参名*toppings中的星号让Python创建一个名为toppings的空元组，并将收到的所有值都封
装到这个元组中,即便函数只收到一个值也如此.'''
    return toppings
def aaa1(name,*top):#第一个值放入name中，其他放入top
    print(str(name))
    print(top)

print("任意数量的关键字实参。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。")
def zidian(fist,last,**user):
    '''形参**user_info中的两个星号让Python创建一个名为user_info的空字典，并将收到的所
有名称—值对都封装到这个字典中。'''
    zidian1={}
    zidian1["fist_name"]=fist
    zidian1["last_name"]=last
    for key,value in user.items():
        zidian1[key]=value
    print(zidian1)
zidian("王","一",xingming="王一")

print("导入整个模块，假设下面是lianxi.py文件。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。")
def lianxi1_function():
    print("这是lianxi1函数")
def lianxi2_function():
    print("这是第二个lianxi函数")
print("这是daoru.py文件.............................................")
# import  lianxi 就导入了lianxi.py文件，可以通过lianxi.函数名调用lianxi.py中的函数。
#导入特定的函数： from lianxi import lianxi2_function,lianxi1_fuction
#导入特定函数这种语法，调用函数时不需要用句点，只需要指定其名称：lianxi1_function
#as 给函数和模块指定别名，对于函数：from lianxi import lianxi2_function as bieming2
#as起别名，对于模块：import lianxi as p
#导入模块中所有函数：from lianxi import *
#所有的import语句都应放在文件开头，唯一例外的情形是，在文件开头使用了注释。

5 类

# coding=utf-8
class Dog():#定义类用关键字class，在类中，所有的函数都称之为方法
    print()
    '''首字母大写的名称指的是类。
这个类定义中的括号是空的'''
    def __init__(self,name,age):
        self.name=name
        self.age=age
        """init方法是构造方法，创建类的实例化对象
        前后两个下划线是避免与普通方法名称发生冲突
        self是一个指向实列本身的引用，让实例能够访问类的属性和方法，必须包含self且位于其他形参前面"""
    def sit(self):
        '''模拟小狗蹲下动作'''
        print(self.name+"蹲下来了")

    def roll(self):
        '''模拟小狗打滚'''
        print(self.name+"在打滚")


mydog=Dog("小白",1)
print("我家狗狗叫"+mydog.name+"今年"+str(mydog.age)+"岁了")
mydog.sit()
mydog.roll()

class Car():
    def __init__(self,name,year):
        '''初始化汽车的属性'''
        self.name=name
        self.year=year
        self.licheng=0

    def get_car(self):
        print("一辆"+str(self.year)+"年的"+self.name+"汽车"+"的里程是"+str(self.licheng))
    def update_car(self):
        self.licheng=20
mycar=Car("荣耀",24)
mycar.get_car()
mycar.licheng=10#直接修改属性的值
mycar.get_car()
mycar.update_car()#通过方法修改属性的值
mycar.get_car()

6 继承与方法的重写

# coding=utf-8
class Car():
    def __init__(self,name,year):
        self.name=name
        self.year=year
        print("调用了父类方法。。。")
    def licheng(self):
        self.licheng1=10

class Car1(Car):#继承父类Car
    def __init__(self, name, year):
        super().__init__(name,year)#调用父类方法
        self.licheng1=0#子类属性
        print("一辆"+name+"车是"+str(year)+"年的，里程是："+str(self.licheng1))
    '''重写父类方法：在子类中定义一个方法，与父类方法同名，
    这样python就不会考虑父类的这个方法而关注子类的这个方法'''

    def licheng(self):#父类方法的重写
        self.licheng1=20
    def get_car1(self):
        print("一辆" + self.name + "车是" + str(self.year) + "年的，里程是：" + str(self.licheng1))

mycar=Car1("荣耀",2)
mycar.licheng()
mycar.get_car1()