【Python入门】详解（有C语言基础为前提）

一、format（）格式化

#方法一
a="名字是：{0},年龄是：{1}"
b=a.format("陈",19)
print(b)
#方法二
c="名字是：{name}，年龄是：{age}"
d=c.format(age=19,name="陈")   #这样format格式化的时候就与顺序无关了
print(d)

 二、字符串的拼接和切割

#split()可以基于指定分隔符将字符串分割成多个子字符串，存储在多个列表当中
#不使用分隔符时，默认使用空白字符
a="hello my name is chenyuru"
print(a.split())  #['hello', 'my', 'name', 'is', 'chenchen']
print(a.split("is"))  #['hello my name ', ' chenchen']

#连接字符串可以用加号+，也可以用join()，几乎不用前者，因为后者效率很高
a=['你好','我的名字','是','陈陈']
b="".join(a)  #你好我的名字是陈陈

三、if else 三元条件运算符

# [条件为真时的值] if [条件表达式] else [条件为假时的值]
num=input("请输入一个数字：")
print(num if int(num)>0 else "是负数")

四、elif多分支选择结构

# if 条件表达式1：
#     语句1
# elif 条件表达式2：
#     语句2
# ...
score=int(input("请输入你的成绩："))
if score<60:
    grade="不及格"
elif score<=80:
    grade="及格"
elif score<=90:
    grade="良好"
else:
    grade="优秀"
print("你的成绩是{0}，等级是{1}".format(score,grade))

五、列表list

1. 列表常识

列表有下标索引；列表中可以存放不同类型的元素；列表大小可变

2.创建列表的方法

#1.创建列表的方式
#① 方法一
a=[1,2,3,4,5,6,7,8,9]
b=[]    #空列表
#② 方法二--使用list可以将任何可迭代的数据转化为列表
c=list()    #空列表
d=list(range(10))  #d=[0,1,2,3,4,5,6,7,8,9]
e=list("chen,nihaoya")  #e=['c', 'h', 'e', 'n', ',', 'n', 'i', 'h', 'a', 'o', 'y', 'a']
#③ 推导式生成列表
f=[x for x in range(10)]   #f=[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
g=[x*2 for x in range(20) if x%2==0]  #g=[0, 4, 8, 12, 16, 20, 24, 28, 32, 36]

3.列表元素的增加

#① append是在原列表尾部增加新元素，速度最快
h=[1,2,3,4]
h.append(5)  #h=[1, 2, 3, 4, 5]
#② +运算符操作 会创建新的列表，涉及大量复制操作,效率低,不建议使用
h=h+[6]   #h=[1, 2, 3, 4, 5, 6]
#③ insert（）将指定元素插入到列表中的指定位置，涉及大量元素的时候要避免使用
h.insert(3,100)   #h=[1, 2, 3, 100, 4, 5, 6]
#④ extend 将目标列表的所有元素添加至本列表的尾部，属于原地操作，不创建新对象
i=[7,8,9,10]
h.extend(i)  #h=[1, 2, 3, 100, 4, 5, 6, 7, 8, 9, 10]
#⑤ 乘法扩展 生成一个新列表，新列表是原列表元素的多次重复
j=h*2  #j=[1, 2, 3, 100, 4, 5, 6, 7, 8, 9, 10, 1, 2, 3, 100, 4, 5, 6, 7, 8, 9, 10]

 4.列表元素的删除

#① del删除列表指定位置的元素
k=[100,200,888,300,400]
del k[2]  #k=[100, 200, 300, 400]
#② pop删除并返回指定位置的元素。如果没有指定位置，删除并返回最后一个
k1=k.pop(3)   #k1=400, k=[100, 200, 300]
#③ remove 删除首次出现的指定元素，如果不存在该元素会报错
l=[100,88,200,88]
l.remove(88)  #l=[100, 200, 88]

5.访问列表中的元素、计数

#① 索引直接访问元素
#② index（）获得指定元素在列表中首次出现的位置
m=[10,20,30,20,40,30,20,20]
m1=m.index(20)  #m1=1  返回整个列表中20第一次出现的位置
m2=m.index(20,3)  #m2=3  返回列表中下标3及其以后的元素中20第一次出现的位置
m3=m.index(20,4,7) #m3=6  返回列表中下标4及其以后至下标为7的元素中20第一次出现的位置
#③ count获得列表中指定元素出现的次数
#④ 用in/not in判断列表中是否存在某个元素

6.切片slice操作

# [:]--提取整个列表
# [start:]--从start开始提取列表
# [:end]--从头提取到end—1
# [start:end:]从start提取到end-1
# [start:end:step]
# 三个量是负数的时候
# [-3：]--提取后三个
# [-5：-3]--倒数第五个到倒数第三个，包头不包尾
# [::-1]--列表逆序
# 注意：如果起始偏移量、终止偏移量超出了列表的范围 不会报错

7.遍历列表+复制列表

#① 遍历
a=[20,10,30,40]
for temp in a:
   print(temp,end=" ")  #20 10 30 40
#② 复制
#错误方法❌（相当于引用，指向的是同一列表）
li1=[1,2,3,4]
li2=li1 #他俩的地址是相同的
#正确方法
li2=[]+li1   #产生了新的列表对象

8.列表排序

#① 修改原列表，不新建列表
n=[20,10,30,40]
n.sort()  #n=[10, 20, 30, 40]  sort默认是升序排序
n.sort(reverse=True)  #n=[40, 30, 20, 10]
   #import random
   #random.shuffle(n)
 #② 建立新列表进行排序--sorted
n1=sorted(n) #默认升序
 #注意有一个易错点：sorted（）是内置函数，语法是sorted（n），而不是n.sorted()
n2=sorted(n,reverse=True)  #降序排序

9.max(),min(),sum()

返回列表中的最大/最小值/纯数值列表的求和

10.二维列表

 和二维数组的操作一样

 六、元组tuple

1.元组常识

元组tuple不能增加、删除、修改元素；可以进行元组的查找、访问、计数等

2.元组的创建

#① 用()创建，()也可以省略
a=(1,2,3) #或者 a=1,2,3
a=(1,)  #元组中只有一个元素的时候，后面要加逗号，不加就是整型了
#② 可以用tuple创建元组
a=tuple() # 空元组
b=tuple("abc")  # b=(a,b,c)
c=tuple(range(5))
d=tuple([1,2,3,4,5])
#tuple()可以接收列表、字符串等生成元组
#list()可以接收元组、字符串等生成列表

3.元组的计数和访问

#索引、index()、count()、切片slice[::]的用法和列表一样

4.元组排序

#对元组排序只能用sorted()--生成新的列表对象
e=(20,10,30,0)
e1=sorted(e)
e2=sorted(e,reverse=True)

5.zip（）

#zip（列表1，；列表2...）将多个列表 对应位置的元素组合成为元组，并生成这个zip对象,❗注意是zip对象
a=(1,2,3)
b=(4,5,6)
c=(7,8,9,10)
d=zip(a,b,c)  #zip object 可以将其转换成list（）或者tutle（）
e=tuple(d)  #或者 e=list(d)

6.生成器推导式生成元组

#列表的生成器推导式生成的就直接是列表，元组生成器推导式生成的是一个生成器对象
#可以通过生成器对象，转化成列表或者元组
a=(x for x in range(5))  #此时的a是一个生成器对象
b=tuple(a) #转化成元组b=(0,1,2,3,4) 但是注意只能转换一次,再次转化生成器对象的时候就是空的了
#也可以使用生成器对象的__next()__方法进行遍历
print(a.__next__())
print(a.__next__())
print(a.__next__())
print(a.__next__())
print(a.__next__()) # 元组中有五个元素，顶多遍历五次，第五次时候指针指向最末尾了就

7.其他

##元组的核心特点是：不可变序列
##元组的访问和处理速度比列表快

七、字典

1.字典常识

键：必须是不可变数据，如整数、浮点数、字符串、元组；
    列表、自带你、集合是可变对象，不能作为键；
    键不可重复，重复的话后面覆盖前面
值：可以是任意数据，且可重复

2.字典的创建

#① 用{}
a={'name':'chenyuru','age':19,'work':'student'}
#② 用dict()创建
b=dict(name='chenyuru',age=19,work='student')
#③ 用zip()创建字典对象
c=['name','age','work']
d=['chenyuru',19,'student']
e=dict(zip(c,d))  #e={'name': 'chenyuru', 'age': 19, 'work': 'student'}
#④ 通过fromkeys()创建值为空的字典
f=dict.fromkeys(['name','age','work'])  #f={'name': None, 'age': None, 'work': None}

3.字典元素的访问

#① 通过键获得值--若键不存在，则抛出异常，不常用
a={'name':'chenyuru','age':19,'work':'student'}
b=a['name']
#② get()方法--比较推荐❗
#指定键不存在时，返回none；也可以设定键不存在时默认返回的对象
a={'name':'chenyuru','age':19,'work':'student'}
b=a.get('name')  #b=chenyuru
c=a.get('gender','性别未知')  #c=性别未知
#③ 列出所有键值对--items()
a={'name':'chenyuru','age':19,'work':'student'}
b=a.items()  #b=dict_items([('name', 'chenyuru'), ('age', 19), ('work', 'student')])
#④ 列出所有的键--keys()/列出所有的值--values()
a={'name':'chenyuru','age':19,'work':'student'}
k=a.keys()
v=a.values()
#⑤ len()键值对的个数
num=len(a)
#⑥ 检测一个键是否在字典中 in/not in
bool_="name"in a

4.字典元素的增加、删除、修改

#① 增加“键值对”
#   键已存在，覆盖旧值；键不存在，新建键值对
a={'name':'chenyuru','age':19,'work':'student'}
a['adddress']='陕西'
a['age']=18
# a={'name': 'chenyuru', 'age': 18, 'work': 'student', 'adddress': '陕西'}
#   update()将新字典中所有键值对全部增添到旧字典；如果key有重复就覆盖  相当于列表中的expend（）
a={'name':'chenyuru','age':19,'work':'student'}
b={'name':'chenchen','age':19,'work':'student'}
a.update(b) #a={'name': 'chenchen', 'age': 19, 'work': 'student'}
#② 删除
#del()
a={'name':'chenyuru','age':19,'work':'student'}
del(a['name'])
#clear()--删除所有键值对
#pop()--弹出指定键值对，并返回所对应的值
age=a.pop('age')
#③ popitem()--随机删除和返回该键值对
#如果想一个接一个移除并处理项，用该方法，因为不用首先获取键的列表
a={'name':'chenyuru','age':19,'work':'student'}
a1=a.popitem()
a2=a.popitem()
a3=a.popitem() #只有三个键值对，只能操作三次，最终a变成空字典

5.序列解包

#序列解包用于字典时，默认是对键进行操作；
#如果要对键值对进行操作，用items()
#如果要对值进行操作，用values()
a={'name':'chenyuru','age':19,'work':'student'}
a1,a2,a3=a  #获得键
#即：a1->name,a2->age,a3->work
a4,a5,a6=a.values()  #获得值
a7,a8,a9=a.items()  #获得键值对

6.字典和列表的结合

r1={'name':'chenyuru','age':19,'work':'student'}
r2={'name':'chenchen','age':18,'work':'worker'}
r3={'name':'chenyu','age':19,'work':'beauty'}
tb=[r1,r2,r3]
for i in range(len(tb)):
    print(tb[i].get('name'),tb[i].get('age'),tb[i].get('work'))

八、集合

#集合无序、可变、元素不重复
#用{}创建集合对象
a={1,2,3}
#用add()方法添加元素
a.add(9)
#用set()可以将列表、元组等转换成集合（原数据中的重复数据会删除）
b=[1,2,3,2]
c=set(b) #c={1, 2, 3}
#remove()删除指定元素
#clear()清空整个集合
#|是并集，&是交集

九、推导式创建序列

1.列表推导式

a=[x for x in range(5)]
b=[x*2 for x in range(1,20) if x%3==0]
c=[ch for ch in "abcdefg"]
#可以使用两个循环，使用zip进行迭代
cells=[(r,c) for r,c in zip(range(1,10),range(101,110))]
for cell in cells:
    print(cell)

2.字典推导式

#格式：{key:value for 表达式 in 可迭代对象}
values={"beijing","shanghai","tianjin"}
citys={id:city for id,city in zip(range(1,4),values)}
print(citys)

3.集合推导式

#格式 {表达式 for item in 可迭代对象}
# 或者 {表达式 for item in 可迭代对象 if 判断条件}
d={x for x in range(100) if x%9==0} #{0, 99, 36, 72, 9, 45, 81, 18, 54, 90, 27, 63}  -->集合是无序的

4，元组推导式

#元组用推导式得到的是一个生成器对象，可以进行一次迭代，也可以用tuple（）转化成元组
e=(x for x in range(9))
for n in e:
    print(n,end=" ")  #0 1 2 3 4 5 6 7 8
for n in e:
    print(n,end=" ") #打印出来是空的，内部指针只能遍历一次
print()
e=(x for x in range(9))
#用tuple()转化成元组，也只能转换一次
f=tuple(e)  #f=(0, 1, 2, 3, 4, 5, 6, 7, 8)

十、函数

1.函数常识

（1）【定义时】形参不必声明类型，也不用指定函数返回类型
（2）【调用时】实参必须与形参一一对应
（3）【return返回值】有return时，执行返回值;无return时，返回None
（4）如果要返回多个值，使用列表、元组、字典、集合将多个值“存起来”即可
（5） python中的函数名本质上就是一个变量

2.变量

如果局部变量和全局变量同名，则在函数内隐藏全局变量，使用局部变量
要在函数内改变全局变量的值，使用global（）声明一下
局部变量的使用效率比全局变量高

3.参数传递

#对[可变对象]进行[写操作]，会直接作用于原对象本身
#[可变对象]有:字典、列表、集合、自定义的对象
#对[不可变对象]进行[写操作]，会产生一个新的[对象空间]，并用新的值填充这块空间
#[不可变对象]有:数字、字符串、元组、function
#可变例子
a=[1,2]
def f(n):
    print("n:",id(n))
    n.append(3)
f(a)
print("a:",id(a))
print(a)
# n: 2546484891968
# a: 2546484891968
# [1, 2, 3]--->可变对象作用于原对象本身
#不可变
#传递对象是不可变参数时，实际传递的时对象的引用。
#在“赋值操作”时，由于不可变对象无法修改，系统会新创建一个对象

#【传递不可变对象包含子对象是可变的情况】
#则方法内修改了这个可变对象，源对象也发生了变化

4.参数类型

1.位置参数-->形参、实参个数要匹配
2.默认值参数-->给参数设定默认值，默认值参数必须位于普通参数后面
3.命名参数--> 按照形参的名称传递参数
4.可变参数-->可变数量的参数
def f2(a,b,*c): #这个就是将多个参数收集到一个元组之中
一个*: 收集到元组中
两个*: 收集到字典之中
5.强制命名参数-->将带星号的可变参数放到默认参数之前时，给后面的参数传参时，要强制带上形参的名字s

十一、lambda表达式

#lambda表达式可以用来声明匿名函数，是一种简单的、在同一行中定义函数的方法
#lambda表达式只允许包含一个表达式，不能有复杂语句，该表达式的计算结果就是函数的返回值
#基本语法:
#lambde 形参... : 表达式
a=lambda a,b,c: a+b+c
print(a(1,2,3))

b=[lambda a:a*2,lambda b:b*3,lambda c:c*3]
print(b[0](1),b[1](2),b[2](3))

十二、eval、nonlocal、global

eval()函数的功能:将字符串str当成有效的表达式来求值并返回计算结果
语法：eval( [一个python表达式或函数] [上下文（可有可无）])

nonlocal --> 用来在内部函数中，声明外层的局部变量
global --> 函数内声明全局变量，然后才能使用全局变量

十三、深拷贝、浅拷贝

#浅拷贝：只复制表面数据，里面的嵌套数据还是共用的
#深拷贝：从头到尾完全复制了，新旧数据完全分开，互不影响

十四、class类

1.类属性、实例属性

#【类属性】【实例属性】
#类属性是从属于类对象的属性，也称为类变量
#类属性可以被所有实例对象共享，通常定义在类内、方法外
#访问类属性可以[类名.属性]或者[实例.属性]
#实例属性的共享范围只有每个实例，通常定义在__init__()方法中
#访问实例属性只能[实例.属性]
class student:
    company="尚学堂"  #类属性
    count=0   #类属性

    def __init__(self,name,score):
        self.name=name       #实例属性
        self.score=score     #实例属性
        student.count+=1

    def say_score(self):   #实例方法
        print("我的公司是：",student.company)
        print("{0}的分数是{1}".format(self.name,self.score))
        #在类内访问实例属性用self,在类外访问实例属性用实例对象名
s1=student("chenyuru",99)  #s1是实例对象，自动调用__init__()方法
s2=student("chenchen",80)
s1.say_score()
print("一共创建了{0}个实例对象".format(student.count))

2.类方法、静态方法

#【类方法】是与类本身绑定的方法，第一个参数是cls（类似于实例方法中的self），需要用@classmethod装饰器定义
#当需要处理所有实例共享的逻辑时，or需要通过类操作属性时（如类属性的统一修改和统计）
#通过类名可以直接调用类方法
class worker:
    company="SXT"

    @classmethod   #类方法
    def printcompany(cls):
        print(cls.company)

    @staticmethod   #静态方法
    def add(a,b):
        print("{0}+{1}={2}".format(a,b,a+b))
        return a+b
#【静态方法】
#静态方法是定义在类内部的普通函数，与类和实例都没有直接绑定，就是一个‘寄生’在类内的工具函数
#比如完成类内部的辅助计算等功能时
#通过类名可以直接调用静态方法

3.__call__()方法

#定义了__call__()的对象，称为'可调用对象'，即该对象可以像函数一样被调用，以“对象名（）”的形式使用
class car:
    def __call__(self,age,money):
        print("call方法")
        print("车龄{0}，金额{1}".format(age,money))

c=car()
c(3,200000)  #这样就使得c这个对象也可以像函数一样被调用

4.方法没有重载

#python中没有方法的重载，有多个同名方法时，只有最后一个有效，会覆盖前面的同名方法

5.方法的动态性

#python是动态语言，可以动态地为类添加新的方法，或者动态地修改类的已有方法
class person:
    def work(self):
        print("努力上班！")

def play_game(s):
    print("玩游戏！")
def work2(s):
    print("好好学习赚大钱！")

person.play=play_game  # 动态添加新方法
person.work=work2  # 动态修改已有方法
     #要注意修改的前后参数要一致
p=person()
p.play()
p.work()
#这块刚才有个报错，调用这两个方法的时候不用传参
#类中自定义的方法都至少有一个self参数，
#第一个参数不管名字叫啥，都是self，
#调用方法的时候不用给self对应的形参位置传实参
#如果方法中只有一个参数，那么他就是self参数，调用的时候括号里头啥都不用写

6.私有属性

#两个下划线开头的属性是私有的
#类内部可以访问私有属性，类外部不能直接访问私有属性
#类外部可以通过[_类名__私有属性（方法）名]访问私有属性
class Employee:
    __company="百战程序员"

print(Employee._Employee__company)

7.@property装饰器

#@property的目的是：让你能像操作普通属性一样，去调用方法，同时又能控制属性的读写行为
#用@property装饰之后，属性本身就只有‘读’的能力
#【@***.setter】装饰器是与【@property】搭配使用的，让原本变成只读的属性又可以继续操作
#让你能用 对象.属性名 = 值 赋值，同时可以在里面加校验逻辑
#两者名字必须相同（比如都叫 salary），才能配对成一个 “可控的属性”。

class emp:
    def __init__(self,name,salary):
        self.name=name
        self.__salary=salary

    @property
    def salary(self):  #这块用salary，而不是__salary的原因：其设计目的就是隐藏内部实现细节
        print("薪资是：",self.__salary)
        return self.__salary

    @salary.setter
    def salary(self,salary):
        if 0<salary<=10000:
            self.__salary=salary
        else:
            print("输入错误！")
e1=emp("chenchen",3000)
e1.salary
e1.salary=9000
e1.salary

8.属性和方法命名规则

#【_xxx】-->保护成员，不能用 from module import*导入，只有类对象和子对象能访问
#【__xxx__】-->系统定义的特殊成员
#【__xxx】-->私有成员，只有类对象能访问，在类外也可以访问

9.类的继承

#若在类中没有指定父类，则默认是[object类]
#继承已有类的语法格式：class 新类（已有类）
#关于构造函数
#子类不重写_int_,实例化子类时，会自动调用父类的_int_
#子类重写了_int_时，实例化子类，就不会调用父类已经定义的_int_
#如果重写了_int_时，要继承父类的构造方法,可用super关键字，也可用以下方法：
#父类名.init(self,参数列表)

class person:
    def __init__(self,name,age):
        self.name=name
        self.age=age

    def say_age(self):
        print("{0}的年龄是{1}".format(self.name,self.age))

class student(person):
    def __init__(self,name,age,score):#重写__init__
        #person.__init__(self,name,age)
        super().__init__(name,age)  #第二种方法
        self.score=score

10.成员继承和方法重写

#成员继承：子类继承了父类除构造方法以外的所有成员（私有方法、私有成员也继承了）
#方法重写：子类重新定义父类的方法之后，就会覆盖父类的方法

11.重写str

class me:
    def __init__(self,name,age):
        self.name=name
        self.age=age
    def __str__(self):
        '''将对象转化成一个字符串描述，一般用于print方法'''
        return "名字是{0}，年龄是{1}".format(self.name,self.age)

m=me("chenchen",19)
print(m)  #名字是chenchen，年龄是19

12.多重继承

#括号中把要继承的多个父类都写上就行了，一般建议少用
#多个父类写的顺序可以根据MRO方法解析顺序自己安排

13.super（）调用父类的方法

#super（）代表父类的定义，不是父类的对象
class A:
    def __init__(self):
        print("构造A")
    def say(self):
        print("A:",self)
        print("say AAA")

class B(A):
    def __init__(self):
        super(B,self).__init__() #调用父类的构造方法
        print("构造B")
    def say(self):
        #A.say(self)  调用A类的say方法
        super().say()  #也可以通过super()调用父类的方法
        print("say BBB")
b=B()
b.say()

14.工厂模式

class CarFactory:
    def createCar(self,brand):
        if brand=="奔驰":
            return Benz()
        elif brand=="宝马":
            return BMW()
        elif brand=="比亚迪":
            return BYD()
        else:
            return "未知品牌"
class Benz():pass
class BMW():pass
class BYD():pass

factory=CarFactory()
c1=factory.createCar("奔驰")
c2=factory.createCar("宝马")
print(c1)
print(c2)

15.单例模式

class MySingleton:
    __obj=None  #定义一个私有类变量__obj，用来存储这个类的唯一实例
    __init_flag=True  #作为初始化开关

    def __new__(cls):  #__new__方法的作用是创建对象，分配内存空间，对象创建后，才会用__init__方法进行初始化
        if cls.obj==None: #第一次创建对象时，__obj是None，所以才会进入这个条件
            cls.obj=object.__new__(cls) #调用基类object的__new__方法，创建一个真正的实例
        return cls.obj
    def __init__(self,name):  #定义初始化方法，用来设置对象的属性
        #self代表创建出来的实例对象，name是传入的参数
        if MySingleton.__init_flag:  #判断初始化开关是否为True
            print("init...")
            self.name=name  #给实例对象设置name属性
            MySingleton.__init_flag=False  #将初始化开关设为false,确保下次不会再被执行初始化

a=MySingleton("aa")
print(a)
b=MySingleton("bb")
print(b)  #会发现a和b的内存地址是一样的，因为只能创建一个实例