Python 学习笔记（最全知识点）

所用编译器VScode

所用学习网站 https://www.liaoxuefeng.com/wiki/1016959663602400

一：输入和输出

n=input()#定义一个变量并输入这个变量
print(n)#自带回车

m=input('please enter your name:')
print(m)


print('aaaa')
print("aaaa")

# 一行输入多个整数 ， 存入列表中并输出
lis = []
lis = list(map(int, input().split()))
for i in range(len(lis)):
    print (lis[i])


#多组输入，读到文件尾
while True:
    try:
        a,b=map(int,input().split())#一行输入多个数
        print(a+b)
    except:
        break

二：list 

#定义一个数组
n =[2,3,4,5]
#输出数组中元素的个数
print(len(n))

print(n[3])
#输出5，下标从0开始

#如果要取最后一个元素，除了计算索引位置外，还可以用-1做索引，直接获取最后一个元素：
print(n[-1])
#同理最后第二个元素-2……只要不越界


#追加元素到末尾
n.append(8)
#插入到指定位置
n.insert(1,6)
#删除末尾的元素
n.pop()
#删除指定位置的元素，默认最后一个，并返回位置
n.pop(1)

n.remove(1)
#用于删除列表中第一个与指定值相等的元素，该值必须存在

#将某个元素换成别的元素
n[1]=9

#删除元素（位置）
del n[3]


#数组元素类型也可以不相同
s=['AAA',123,true]

#可以list套list,相当于二维数组
p=['123','456',['789','aaa']]

a=['c','b','a']
a.sort()
print(a)
#list是可变对象，输出['a','b','c']

#sort()是Python列表的一个内置的排序算法，list.sort()方法排序时直接修改原列表，返回None
#sorted()是Python内置的一个排序函数，它会从一个迭代器返回一个排好序的新列表

#定义一个串是不可变对象
a='abc'
print(a.replace('a','A'))#输出Abc
print(a)#输出abc

#列表推导式


x = [i*i for i in range(10)]
print(x)
#输出[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

xx = [-1,-4,6,7.5,-2.3,9,-11]
y = [i for i in xx if i>0]
print(y)
#输出[6, 7.5, 9]

三：条件判断 

#根据Python的缩进规则，如果if语句判断是True，就把缩进的两行print语句执行了，否则，什么也不做。
n=8
if n>=8:
    print("yes")
    print("YES")
else:
    print("NO")
    print("no")

 四：循环

（1）for循环 

n=[1,2,3,4]
for n in n:
    print(n)
#输出每个元素

#计算1到10的和
sum=0
for x in [1,2,3,4,5,6,7,8,9,10]:
    sum=sum+x
print(sum)

#那要是计算1到100呢
#Python提供了一个函数range()，可以生成一个整数序列，再通过list()函数可以转换为list。
#range(start,end,step)step默认为1，经常不写
#eg:  list(range(10,1,-3))  [10,7,4]
#range(101)生成0到100的序列
#range(1,101)生成1到100的序列


sum2=0
for x in list(range(101)):
    sum2+=x
print(sum2)




#编程计算1-2!+3!-4!+5!...前n项的值。
n=input()
n=int(n)#先转换成int型
sum=0
p=1
for i in range(1,n+1):
    p*=i
    if i%2==0 :
        sum-=p
    else:
        sum+=p
print(sum)

（2）while循环

#计算1到100的和
sum=0
n=100
while n>0:
    sum=sum+n
    n=n-1
print(sum)

#可以使用break跳出循环，continue提前结束本轮循环，并直接开始下一轮循环

#“死循环”可以用Ctrl+C退出程序

五：使用dict和set

dict全称dictionary，在其他语言中也称为map，使用键-值（key-value）存储，具有极快的查找速度。

（1）dict（空间来换取时间）

d={'A':2,'B':5,'V':7}
print(d['V'])#输出7
#'p'不存在可以在后面放入值，如果已经存在就替换,
d['P']=8
print(d['P'])
x=dict()#创建一个空的字典

#要避免key不存在的错误，有两种办法in 或者get
print('B' in d)#输出True
print(d.get('C'))#输出None
print(d.get('C',-1))#自定义不存在输出-1，存在输出键值

#删除一个
d.pop('A')
print(d)#输出{'B': 5, 'V': 7, 'P': 8}

#设计一个字典，用户输入一个‘键’，存在则输出值，不存在则输出-1
x={'xjh':99,'zcy':98}
name=input('请输入你的姓名：')
if x.get(name,-1) == -1:
    print('该姓名不存在')
else:
    print(x[name])

#编写程序，生成包含1000个0~100之间的随机整数，统计并输出每个整数出现的次数
import random
x={}
for i in range(1000):
    y=random.randint(0,100)
    y=int(y)
    if x.get(y,-1) == -1:
        x[y] = 1
    else:
        x[y] = x[y] + 1

for k,v in x.items():
    print(k,v)

 （2）set    set和dict类似，也是一组key的集合，但不存储value。由于key不能重复，所以，在set中，没有重复的key。

s=set([1,2,3])
print(s)
ss=set([1,1,2,2,2,3])
print(ss)
#s和ss存储的元素个数是一样的，都是输出{1, 2, 3}
x=set()#创建一个空集合
s.pop()#删除一个随机的元素，并返回这个元素
s.add(5)#增加元素
s.remove(3)#删除元素

#两个set可以做数学意义上的交集、并集等操作
p=set([1,2,3])
pp=set([2,3,4])
print(p&pp)#输出{2,3}
print(p|pp)#输出{1,2,3,4}

五：函数

1.调用函数

#调用abs函数
print(abs(12.34))
print(abs(2))
#函数max()可以接收任意多个参数，并返回最大的那个
print(max(1,2))
print(max(1,2,3,4,5))
#用来数据类型转换的函数
print(int('123')) #123
print(int(12.34)) #12
print(float('12.34')) #12.34
print(str(1.23)) #'1.23
print(bool('')) #False

a=abs # 变量a指向abs函数
print(a(-1))  # 所以也可以通过a调用abs函数

#求和函数
r = [1, 2, 3, 4, 5, 6]
print(sum(r))

2.定义函数（在Python中，定义一个函数要使用def语句，依次写出函数名、括号、括号中的参数和冒号:，然后，在缩进块中编写函数体，函数的返回值用return语句返回。）

#eg:定义一个绝对值的函数
def my_abs(x):
    if x>=0:
        return x
    else:
        return -x

print(my_abs(-2))



#可以返回多个值
import math

def move(x,y):
    x=x+1
    y=y-1
    return x,y

print(move(1,2))

3.函数的参数

def power(x,n=2):#默认参数在后
    s = 1
    while n>0:
        n=n-1
        s=s*x
    return s
print(power(5))
print(power(5,2))

#计算a*a+b*b+……
def calc(numbers):
    sum = 0
    for n in numbers:
        sum =sum +n*n
    return sum
print(calc(([1,2,3])))   #14
print(calc([1,3,5,7]))   #84

#可以变为可变参数，调用简单一点,一个*接受多个位置参数并将其放在一个元组中
def calc1(*numbers):
    sum = 0
    for n in numbers:
        sum =sum +n*n
    return sum
print(calc1(1,2,3))   #14
print(calc1(1,3,5,7))   #84

nums =[1,2,3]
#对于已经存在的数组，有以下两种调用方式
print(calc1(nums[0],nums[1],nums[2]))
print(calc1(*nums))

#**接受多个关键位置参数并存放到字典中
def demo(**p):
    for item in p.items():
        print(item)
print(demo(x=1,y=2,z=3))

#输出
#('y', 2)
#('x', 1)
#('z', 3)
#关键字参数
def person(name,age,**kw):
    print('name:',name,'age:',age,'other:',kw)
person('Bob',35,city='Beijing',job='student')
#输出name: Bob age: 35 other: {'city': 'Beijing', 'job': 'student'}

4.递归函数

#计算n!
def fact(n):
    if n==1:
        return 1
    return n*fact(n-1)
print(fact(3))

5.变量作用域

#全局变量可以用关键字global来定义
#（1）一个变量已在函数外定义，如果函数内需要为这个变量赋值，并要将这个赋值结果反映到函数外，
#可以在函#数内使用global将其声明为全局变量
#（2）如果一个变量在函数外没有定义，在函数内部也可以直接将一个变量定义为全局变量，该函数执行后，将增#加一个新的全局变量。
#注意：在某个作用域内任意位置只要有为变量赋值的操作，该变量在这个作用域内就是局部变量，除非使用#global进行了声明。
#eg:
x = 3
def f():
    print(x)#本意是输出x的值，但是不允许这样做
    x = 5
    print(x)

f()

6.lambda表达式

#lambda用来声明匿名函数，或者定义具名函数
#lambda表达式只可以包含一个表达式，该表达式的计算结果可以看做是函数的返回值，
#不允许包含复合语句，但在表达式中可以调用其它函数。
f = lambda x, y, z: x + y + z #可以给lambda表达式起名字
print(f(1, 2, 3))  #像函数一样调用，输出6
g = lambda x, y=2, z=3: x + y + z #参数默认值
print(g(1))#输出6
print(g(2,z=4,y=5))#输出11


print(123)
L = [1, 2, 3, 4, 5]
print(list(map(lambda x:x+10,L)))#模拟向量运算
#输出[11,12,13,14,15],L的值并未变。

六：高级特性

1.切片

#[start:end:step]
#step默认为1，可以不写可以为正，也可以为负


L = ['Michael','Sarach','Tracy','Bob','Jack']
#取前3个元素
#方法1：
print( [ L[0],L[1],L[2] ] )

#方法2：
r = []
n=3
for i in range(n):
    r.append(L[i])
print(r)

#方法3:切片
print( L[0:3] ) #如果第一个索引是0，还可以省略：print( L[:3] )
print( L[1:3] ) #从1开始取2个元素
print( L[1:]) #从1开始取到末尾
#类似的，既然Python支持L[-1]取倒数第一个元素，那么它同样支持倒数切片，试试：
print( L[-2:] )#输出['Bob', 'Jack']
print( L[-2:-1] )#输出['Bob']


#在举一个切片的例子，加深理解
R = list(range(100)) #创建一个0-99的数列
print( R[:10] ) #取前10个数
print( R[-10:] ) #取后10个数
print( R[10:20] ) #取11-20个数
print( R[:10:2] ) #前10个数，每两个取1个
print( R[::5] ) #所有数，每5个取1个
print( R[:] ) #可以复制一个list
#同样字符串'XXX'也可以看成一种list
print( 'ABCDEFG'[:3])

alist=[3,5,7]
alist[len(alist):]=[9]#在列表尾部增加元素
alist[:0]=[1,2]#在列表头部插入
alist[3:3]#在列表中间位置插入
alist[:3]=[]#删除前三个元素
alist[:3]=[1,2,3]#替换列表元素

2.迭代

d = {'a': 1, 'b': 2, 'c': 3}
#默认情况下，dict迭代的是key
for key in d:
    print(key)
#迭代value
for value in d.values():
    print(value)
#同时迭代key和value
for k, v in d.items():
    print(k, v)
#输出
# ('a', 1)
# ('c', 3)
# ('b', 2)
for i, value in enumerate(['A', 'B', 'C']):
    print(i, value)
#输出
#(0, 'A')
#(1, 'B')
#(2, 'C')

#引用两个变量
for x, y in [(1, 1), (2, 3), (3, 6)]
    print(x, y)

3.列表生成式

#生成【1*1，2*2,3*3……】
#方法1
L = []
for x in range(1, 11):
    L.append(x * x)
print(L)
#方法2
print( [x*x for x in range(1,11)] )


#for循环后面还可以加上if判断，这样我们就可以筛选出仅偶数的平方：
print([x*x for x in range(1,11) if x%2==0])
#输出[4, 16, 36, 64, 100]

#还可以使用两层循环，可以生成全排列：
print( [x+y for x in 'ABC' for y in 'XYZ'] )
#输出['AX', 'AY', 'AZ', 'BX', 'BY', 'BZ', 'CX', 'CY', 'CZ']

#dict的items()可以同时迭代key和value
d = {'x': 'A', 'y': 'B', 'z': 'C'}
for k, v in d.items():
    print(k, '=', v)
#或
[k+'='+v for k,v in d.items()]

#把一个list中所有的字符串变成小写：
L = ['Hello', 'Word', 'ABC']
print( [s.lower() for s in L] )

#使用内建的isinstance函数可以判断一个变量是不是字符串：
x = 'abc'
y = 123
print(isinstance(x, str))#True
print(isinstance(y, str))#False
print(isinstance(y,int))#True

4.生成器

#创建一个generator
g = (x * x for x in range(10))

for n in g:
    print(n)

七：函数式编程

1.高阶函数

#map()函数接收两个参数，一个是函数，一个是Iterable
#eg:比如我们有一个函数f(x)=x2，要把这个函数作用在一个list [1, 2, 3, 4, 5, 6, 7, 8, 9]上，就可以用map()实现如下
def f(x):
    return x * x
r = map(f, [1, 2, 3, 4, 5, 6, 7, 8, 9])
print(list(r))

#把这个list所有数字转为字符串
r = map(str, [1, 2, 3, 4, 5, 6, 7, 8, 9])
print(list(r))
#把这个list所有数字转为正数
r = map(abs, [-1, -2, -3, -4, -5, 6, 7, 8, 9])
print(list(r))

#reduce把一个函数作用在一个序列[x1, x2, x3, ...]上，这个函数必须接收两个参数
# reduce把结果继续和序列的下一个元素做累积计算，其效果就是：
# reduce(f, [x1, x2, x3, x4]) = f(f(f(x1, x2), x3), x4)
#eg：求和
from functools import reduce
def add(x, y):
    return x + y
print(reduce(add,[1,2,3,4,5,6]))

#把序列[1, 3, 5, 7, 9]变换成整数13579
from functools import reduce
def fn(x, y):
    return x * 10 + y
print(reduce(fn,[1,2,3,5,7,9]))

##sorted()
print(sorted([36,5,-6,3,78]))
#[-6, 3, 5, 36, 78]

#sorted()函数也是一个高阶函数，它还可以接收一个key函数
#来实现自定义的排序，例如按绝对值大小排序
print(sorted([36,-5,6,-3,78],key=abs))
#[-3, -5, 6, 36, 78]

#我们给sorted传入key函数，即可实现忽略大小写的排序
print(sorted(['bob','ABC','Zoo','Cread','Ca'],key=str.lower))
#输出['ABC', 'bob', 'Ca', 'Cread', 'Zoo']

#要进行反向排序，不必改动key函数，可以传入第三个参数
print(sorted(['bob','ABC','Zoo','Cread','Ca'],key=str.lower,reverse=True))

print(sorted([('Bob',75),('Csd',89),('Adf',99),('Adf',88)]))
#输出[('Adf', 88), ('Adf', 99), ('Bob', 75), ('Csd', 89)]

2.匿名函数

print ( list(map(lambda x: x*x,[1,2,3,4,5,6,7,8])) )
#lambda x:x*x相当于定义一个函数,:前面的x表示函数参数

f=lambda x:x*x
print( f(5) )

#同样，也可以把匿名函数作为返回值返回
def bulidd(x,y):
    return lambda: x*x +y*y
f = bulidd(3,3)
print( f() )

3.偏函数

#int()函数还提供额外的base参数，默认值为10。
#如果传入base参数，就可以做N进制的转换
print(int('12345',base = 8))
print(int('12345',8))

#可以定义一个int2()的函数，默认把base=2传进去：
def int2(x,base = 2):
    return int(x,base)
print(int2('10000'))

#functools.partial就是帮助我们创建一个偏函数的，不需要我们自己定义int2()，
# 可以直接使用下面的代码创建一个新的函数int2：
import functools
int2 = functools.partial(int,base=2)
print(int2('10000'))
#简单总结functools.partial的作用就是，把一个函数的某些参数给固定住
#（也就是设置默认值），返回一个新的函数，调用这个新函数会更简单。

八：面向对象编程

1.类和实例

#创建一个类，类是一种具有相同属性和方法的抽象
#创建类需要使用class关键字，并且定义方法时，方法的第一个参数是self
class Student(object):
    #这点与C/C++、C#的语法不同，简单区别下，定义类属性需要在特殊方法__init__内部
    def __init__(self,name,score):
        self.name = name#这里才是类内的属性，为类属性
        self.score =score#同样的，这也是类属性
    def fun(self):
        print("这就是类内定义一个类的方法")
    def print_name(self):
        print(self.name)
    def print_score(self):
        print(self.score)
    def get_grade(self):
        if self.score >=90:
            return 'A'
        elif self.score >=60:
            return 'B'
        else:
            return 'C'

#创建实例是通过类名+()实现的
bar = Student("ZCY",100)
bar.print_name()
bar.print_score()
print(bar.get_grade())

print(bar.score)#可以从外部访问变量（相当于Public）

2.访问限制

#如果要让内部属性不被外部访问，可以把属性的名称前加上两个下划线__，
#在Python中，实例的变量名如果以__开头，就变成了一个私有变量（private），
#只有内部可以访问，外部不能访问，所以，我们把Student类改一改：
class Student(object):
    def __init__(self,name,score):
        self.__name = name
        self.__score = score
    def print_score(self):
        print(self.__score)
    def print_name(self):
        print(self.__name)
    def get_name(self):
        return self.__name
    def get_score(self):
        return self.__score
    def set_score(self,score):
        self.__score = score
    def set_name(self,name):
        self.__name = name

bar = Student("ZCY",100)
bar.print_name()
print(bar.get_name())
bar.set_name("XJH")
print(bar.get_name())

#改完后，对于外部代码来说，没什么变动，但是已经无法从外部访问实例变量.__name和实例变量.__score了
#如果外部想访问，我们加一个print_score()和print_name()方法就可以了,如上代码
##如果外部想得到，我们加一个get_score()和get_name()方法就可以了,如上代码
#如果外部想修改，我们加一个set_score()和set_name()方法就可以了，如上代码

#并且以双下划线结尾的，是特殊变量，特殊变量是可以直接访问的，不是private变量，
#所以，不能用__name__、__score__这样的变量名。

3.继承和多态

#继承最大的好处是子类获得了父类的全部功能
class Animal(object):
    def run(self):
        print('我是父类')
class Dog(Animal):
    def RUN(self):
        print('我是子类')

animal = Animal()
animal.run()

dog = Dog()
dog.run()

#覆盖：如果子类父类里面都有run()方法时，我们称子类的run覆盖了
#父类的run，在代码运行的时候，总是会调用子类的run()
class Animal(object):
    def run(self):
        print('11')

class Dog(Animal):
    def run(self):
        print('22')
p=Dog()
p.run()#输出22
pp=Animal()

#判断一个变量是否是某个类型可以用isinstance()判断：
print( isinstance(p,Animal)) #True
print( isinstance(p,list)) #False
print( isinstance(p,Dog)) #True
print( isinstance(pp,list))#False
print( isinstance(pp,Dog))#False
print( isinstance(pp,Animal))#True
#所以p时Dog类型的，还时Animal类型的

九：面向对象高级编程

1.使用__slots__

#创建一个class实例
class Student(object):
    pass
#然后实例绑定一个属性
s = Student()
s.name = 'Michael'
print(s.name)

#给实例绑定一个方法
def set_age(self,age):# 定义一个函数作为实例方法
    self.age=age
from types import MethodType
s.set_age=MethodType(set_age,s)# 给实例绑定一个方法
s.set_age(25)# 调用实例方法
print(s.age)# 测试结果

#但是，给一个实例绑定的方法，对另一个实例是不起作用的
s2 = Student()
#s2.set_age(25)#不能这样写

#为了给所有实例都绑定方法，可以给class绑定方法：
def set_score(self,score):
    self.score=score
Student.set_score = set_score

#给class绑定方法后，所有实例均可调用：
s.set_score(100)
print(s.score)
s2.set_score(99)
print(s2.score)

#使用__slots__:限制实例的属性
#使用__slots__:限制实例的属性
class Student(object):
    __slots__ = ('name','age')

s = Student() # 创建新的实例
s.name = 'Michael' # 绑定属性'name'
s.age = 25 # 绑定属性'age'
#s.score = 99 # 绑定属性'score'
#由于'score'没有被放到__slots__中，所以不能绑定score属性

#使用__slots__要注意，__slots__定义的属性
#仅对当前类实例起作用，对继承的子类是不起作用的

#除非在子类中也定义__slots__，这样，子类实例允许
#定义的属性就是自身的__slots__加上父类的__slots__

学习中……

番外：Python math包

#除非有说明，math的函数都返回浮点数
import math

print(math.ceil(5.7)) #上取整 输出6
print(math.floor(5.6))#下取整 输出5

print(math.factorial(3))#3的阶乘 输出6

print(math.gcd(2,4))#最大公约数 输出2
print(math.gcd(0,0))#输出0

print(math.sqrt(4))#平方根 输出2。0

print(math.log(4,2))#log(x,y)表示x以y为底的对数
print(math.log2(8))#返回 x 以2为底的对数 输出 3.0
print(math.log10(100))#返回 x 以10为底的对数 输出 2.0

print(math.pow(2,3))#输出2的3次方

print(math.pi)#输出3.141592653589793
print(math.e)#输出2.718281828459045

print(math.sin(math.pi/2))#返回 x 弧度的正弦值。输出1.0
#类似的还有math.tan(x) math.cos(x) 注意都是弧度
#math.asin() math.acos() math.atan()

print(math.degrees(math.pi/2))#将角度 x 从弧度转换为度数。 输出90.0
print(math.radians(180))# 将角度 x 从度数转换为弧度。输出3.141592653589793