Python学习笔记

最新推荐文章于 2021-07-30 23:03:12 发布

ykcckkc

最新推荐文章于 2021-07-30 23:03:12 发布

阅读量98

点赞数

本文链接：https://blog.csdn.net/ykcckkc/article/details/118896597

版权

1：Python简介：解释型计算机程序设计语言，特色之一是使用空白符作为强制语句缩进，是一门胶水语言，拥有强大和丰富的库

2：API（application programming interface）：应用程序编程接口，查字典的学习方式使用API

3：IDE（integrated development environment）：集成开饭环境，pycharm等开发软件

4：配置path环境变量可以方便在window命令行中使用Python，否则只能进入目标安装环境才可以使用。

5：导入Python模块:

from module_name import function_name

from module_name import *  # 导入所有的函数

6：直接声明变量类型：

variable_name = variable_value

变量名只包含数字，字母，下划线，且不能用数字作为开头

7：可以用fomat函数进行数字格式化，包括小数点形式，数字左右对齐，以及千位分隔符等。

8：使用utf-8编码格式保存源代码文件

# coding=utf-8

9：使用转义字符/解决字符串表达原意问题，如' "等

10：用+拼接字符串，‘hello’+‘world’ = ‘helloworld’

11：限制转移字符：字符串前面加r

12：设置print函数的打印间隔以及结尾

print('a','b','c',sep=',',end='')

13：序列解包方式，链式，增量赋值：

x,y,z = 1,2,3
x = y = z = 1
x += 2

14：代码块是在条件为真时执行的一组语句，通过在代码前放置空格来缩进语句创建代码快（用4个空格，而不是用tab八个空格）

15：比较运算符：==，< , >, >=, <=, !=, is(同一个对象）, in（在容器中）

16：断言（assert），在程序运行不符合条件时，抛出异常，便于及时处理bug。

17：使用exec执行字符串中的代码(注意函数的作用域：

exec('print('hello world')

18：数据结构（通过某种方式组织在一起的数据元素的集合，可以是任意数据类型的元素），序列（每一个元素被分配一个编号）：列表和元组

定义序列：直接赋值，可以是任意不同数据类型的元素值，也可以是另外一个序列

x = ['apple', 1, 2.3, True, []]

序列的基本操作：索引，切片，加，乘。

x = ['apple', 1, 2.3, True, []]
x[1]
x[1:2]  x[:]  x[1:]  x[:3]  x[1:-2}# 包前不包后
x[1:4:2]  x[1:3;-1] # 设置索引的步长

序列也可以像字符串一样进行相加操作，但不能序列加字符串

列表元素赋值，删除，分片赋值

x[1] = 1
del x[1]
x[1:3] = 1,2
x[1:3} = list[:]

列表方法：

x.append(5)
x.append([8,5])  # 在列表最后插入新值，[]为加入一个空列表
x.clear()  # 清除列表值
y = x  # 复制列表
x.count(1)  # 返回列表中元素的出现次数
x.extend(y)  # 连接y列表在x列表后面，连接列表
x.index(1)  # 返回元素索引位置
x.insert(3,'4')  # 在第四个元素的位置插入一个4
x.pop(1)  # 返回删除的相应位置元素，默认是最后一个元素
x.remove(1)  # 删除元素1，不返回
x.reverse  # 列表元素值倒序排放
x.sort()  # 列表元素按升序排列

元组也是一种序列，与列表的区别是它不能修改，只是可读

1,2,3,4,23 
(1.23，23,212)  # 元组的两种表示形式
23，
(23，)  # 只有一个元素值的元组
()  # 空元组
x = tuple([1,23,3])  # 列表转化成元组

19：字典：映射（mapping）类的数据结构类型，用于查询，查询速度与数据量无关。

创建字典过程中，注意键的唯一性，对相同的键赋值会覆盖原有的值。

使用dict函数通过其他映射（如其他字典）或键值对的序列简历字典

item = [['bill','1234'], ('mike','4321'),['marry','7753;]
d = dict(item)
item = dict('name'='bill', 'number'='5678', 'age'=45)
运行结果：{'name':'bill', 'number':'5678', 'age':45}

len(dict)  # 返回字典dict中键值对的数量
dict[key]  # 返回关联到键key上的值
dict[key] = value  # 将value关联到key上
del dict[key]  # 删除键为key的项
key in dict  # 判断dict中是否含有键为key的项

字典与列表的区别：键类型（字典的键是任意可变类型，列表只能是整型），自动添加（字典通过键值自动添加未包含的项，而列表需要通过append，insert添加元素），查找成员（字典查找key，列表查找value）

同时获取key和value的列表

for key,value in dict.items():
    print(key, value, end=' ')

并行迭代

names = ['bill','marry','jojn']
ages = [30,40,50]
for i in range(len(names)):
    print(names[i],ages[i],end=' ')

压缩迭代

companies = ['a', 'b', 'c']
websites = ['sss', 'sfa']
for value in zip(companies, websites):
    print(value, end=' ')

20：子类继承父类属性和方法：

# 父类
class ParentClass:
    def method1(self):
        print('method1')

# 子类
class ChildClass(ParentClass):
    def method2(self):
        print('method2')


child = ChildClass()
child.method1()
child.method2()

21:检测继承关系

# 检测继承关系

# A  B
#  issubclass(childclass,parentclass)
#  isinstance(obj, class)
#  classname.__bases__
class MyParentClass:
    def method(self):
        return 50
class ParentClass(MyParentClass):
    def method1(self):
        print('method1')
class ChildClass(ParentClass):
    def method2(self):
        print('method2')
class MyClass:
    def method(self):
        return 10
print(issubclass(ChildClass, ParentClass))  # True
print(issubclass(ChildClass, MyClass))      # False
print(issubclass(ChildClass, MyParentClass))# True

print(ChildClass.__bases__)
print(ParentClass.__bases__)
print(MyClass.__bases__)

child = ChildClass()
print(isinstance(child, ChildClass))
print(isinstance(child, ParentClass))
print(isinstance(child, MyClass))

22：接口，调用对象前判断接口是否存在

class Person:
    name = None
    def walk(self):
        print('walk')
class Teacher(Person):
    def getField(self):
        print('我教的是化学')
class Student(Person):
    def test(self):
        print('我最讨厌考试')
def gotoSchool():
    print('去学校上课')
student = Student()
setattr(student, 'gotoSchool', gotoSchool)
student.gotoSchool()

23：自定义异常

# 定义曲速引擎过载的异常类
class WarpdriveOverloadException(Exception):  # 自定义的异常类必须是Exception的子类
    pass

# 当前的曲速值
warpSpeed = 12
if warpSpeed > 10:
    raise WarpdriveOverloadException("曲速引擎已经过载，请停止或弹出曲速核心，否则飞船会爆炸")

24：捕捉异常：

# 表示操作数或计算结果为负数时抛出的异常
class NegativeException(Exception):
    pass
# 表示操作数为0时抛出的异常
class ZeroException(Exception):
    pass

class SpecialCalc:
    def add(self,x,y):
        if x < 0 or y < 0:
            raise NegativeException('x或y小于0')
        return x + y
    def sub(self,x,y):
        if x - y < 0:
            raise NegativeException('x - y 小于0')
        return x - y
    def mul(self,x,y):
        if x == 0 or y == 0:
            raise ZeroException('x == 0或y == 0')
        return x * y
    def div(self,x,y):
        return x / y
while True:
    try:
        calc = SpecialCalc()
        expr = input('请输入要计算的表达式，例如，add(1,2)：')
        if expr == ':exit':
            break;
        result = eval('calc.' + expr)
        print('计算结果：{:.2f}'.format(result))
    except NegativeException:
        print('*****负数异常*******')
    except ZeroException:
        print('*****操作数为0异常******')
    except ZeroDivisionError:
        print('*****分母不能为0********')
    except:
        print('*****抛出其他异常******')


# 同时处理多个异常
'''
try:
    ... ... 
except(异常类1,异常类2,异常类3....):
    ... ...
'''

class CustomException1(Exception):
    pass
class CustomException2(Exception):
    pass
class CustomException3(Exception):
    pass

import random

def raiseException():
    n = random.randint(1,3)
    if n == 1:
        raise CustomException1
    elif n == 2:
        raise CustomException2
    else:
        raise CustomException3
try:
    raiseException()
except(CustomException1, CustomException2, CustomException3):
    print('*******处理异常的程序*******')

25：构造方法__init__:一般用于类间的变量初始化，重写普通方法、构造方法，使用super函数（可以继承超类方法，弥补重写的构造方法）

# 使用super函数
class Bird:
    def __init__(self):
        self.hungry = True
        print('Bird的构造方法')
    def eat(self):
        if self.hungry:
            print('已经吃了虫子')
            self.hungry = False
        else:
            print('已经吃过了')
b = Bird()
b.eat()
b.eat()

class SongBird(Bird):
    def __init__(self):
        super().__init__()
        self.sound = '唱歌'
        print('SongBird的构造方法')
    def sing(self):
        super().eat()
        print(self.sound)

sb = SongBird()
sb.sing()
sb.eat()
print("---------------")
class MyClass0:
    def __init__(self):
        print('MyClass0')
class MyClass1(MyClass0):
    def __init__(self):
        print('MyClass1')
    
class MyClass2(MyClass1):
    def __init__(self):
        print('MyClass2')
class MyClass3(MyClass2):
    def __init__(self):
        print('MyClass3')
        super(MyClass1,self).__init__()
m = MyClass3()

26：对象的属性

属性与property函数
class Rectangle:
    def __init__(self):
        self.left = 0
        self.top = 0
    def setLeft(self,left):
        self.left = left
    def setPosition(self,position):
        print('setPosition被调用')
        self.left, self.top = position
    def getPosition(self):
        print('getPosition被调用')
        return self.left, self.top
    def deletePosition(self):
        print('position属性已被删除')
        self.left = 0
        self.top = 0
    position = property(getPosition, setPosition,deletePosition)
r = Rectangle()
r.left = 100
print(r.left)
#r.setPosition([400,500])
#print(r.getPosition())

r.position= 123,456
print(r.position)

del r.position
print(r.position)

'''
100
setPosition被调用
getPosition被调用
(123, 456)
position属性已被删除
getPosition被调用
(0, 0)
'''


# 监控对象中的所有属性
'''
__getatrr__(self, name):用来监控所有的属性读操作
__setattr__(self,name,value):用来监控所有的属性写操作
__delattr__(self,name):用来监控所有的属性的删除操作

'''

class Rectangle:
    def __init__(self):
        self.width = 0
        self.height = 0
        self.left = 0
        self.top = 0
    def __setattr__(self, name, value):
        print('{}被设置，新值为{}'.format(name, value))
        if name == 'size':
            self.width, self.height = value
        elif name == 'position':
            self.left, self.top = value
        else:
            self.__dict__[name] = value
    def __getattr__(self,name):
        print('{}被获取'.format(name))
        if name == 'size':
            return self.width,self.height
        elif name == 'position':
            return self.left,self.top
    def __delattr__(self,name):
        if name == 'size':
            self.width,self.height = 0,0
        elif name == 'position':
            self.left,self.top = 0,0
r = Rectangle()
r.size = 100,200
r.position = 1,2

print(r.size)
print(r.position)

del r.size,r.position
print(r.size)
print(r.position)

print('-------------')
class MyClass:
    def __setattr__(self, name, value):
        if name == 'value':
            if value > 0:
                self.__dict__[name] = value
            else:
                print('{}属性的值必须大于0'.format(name))
        else:
            self.__dict__[name] = value

c = MyClass()
c.value = 20
print('c.value','=',c.value)
c.value = -123
print('c.value','=',c.value)


'''
width被设置，新值为0
height被设置，新值为0
left被设置，新值为0
top被设置，新值为0
size被设置，新值为(100, 200)
width被设置，新值为100
height被设置，新值为200
position被设置，新值为(1, 2)
left被设置，新值为1
top被设置，新值为2
size被获取
(100, 200)
position被获取
(1, 2)
width被设置，新值为0
height被设置，新值为0
left被设置，新值为0
top被设置，新值为0
size被获取
(0, 0)
position被获取
(0, 0)
-------------
c.value = 20
value属性的值必须大于0
c.value = 20
'''

27:类的三种方法：实例方法，静态方法，类方法

实例方法必须先实例化才可以调用，静态方法在调用时不需要类的实例，类方法调用方式与今天方法完全一样，不同的是，对于实例方法来说self参数代表当前类的实例，可以通过self访问对象的属性和方法，类方法不能通过self参数访问对象中的属性和方法，只能通过self参数访问静态方法和静态属性。

class MyClass:
    # 实例方法
    def instanceMethod(self):
        pass

    # 静态方法
    @staticmethod
    def staticMethod():
        pass
        
    # 类方法
    @classmethod
    def classMethod(self):
        pass

class MyClass:
    # 定义一个静态变量，可以被静态方法和类方法访问
    name = 'Bill'
    def __init__(self):
        print('MyClass的构造方法被调用）
        # 定义实例变量，静态方法和类方法不能访问该变量
        self.value = 20
    # 定义静态方法
    @staticmethod
    def run():
        # 访问MyClass类中的静态变量name
        print('*',MyClass.name,'*')
        print('MyClass的静态方法run被调用')
    # 定义类方法
    @classmethod
    # 这里的self是类的元数据，不是类的实例
    def do(self):
        print(self)
        # 访问MyClass类中的静态变量name
        print('调用静态方法run')
        self.run()
        # 在类方法中不能访问实例变量，不然会派出异常（因为实例变量需要用类的实例访问）
        # print(self.value)
        print(‘成员方法do被调用’）

28：迭代器：在类中定义__iter__方法，那么这个类的实例就是一个迭代器，__iter__方法需要返回一个迭代器。

# 自定义可迭代的类

# for value in values:

'''
  __iter__(self)
  
  __next__(self)
'''
class RightTriangle:
    def __init__(self):
        self.n = 1
    def __iter__(self):
        return self
    def __next__(self):
        result = '*' * (2 * self.n - 1)
        self.n += 1
        return result
rt = RightTriangle()
for e in rt:
    if len(e) > 20:
        break;
    print(e)

# 可无限迭代的斐波那契数列
class Fibonacci:
    def __init__(self):
        self.a = 0
        self.b = 1
    def __iter__(self):
        return self
    def __next__(self):
        result = self.a
        self.a,self.b = self.b, self.a + self.b
        return result
fibs = Fibonacci()
for fib in fibs:
    print(fib,end = ' ')
    if fib > 500:
        break;


# 将迭代器转换为列表

class Fibonacci:
    def __init__(self):
        self.a = 0
        self.b = 1
    def __iter__(self):
        return self
    def __next__(self):
        result = self.a
        self.a,self.b = self.b, self.a + self.b
        if result > 500: raise StopIteration
        return result
fibs = Fibonacci()
print(list(fibs))

29：生成器：迭代是以类为基础的单值产生器，则生成器是以函数为基础的单值产生器，生成器可以通过一个函数展现，可以直接调用。

# 定义一个生成器函数
def myGenerator():
    numList = [1,2,3,4,5,6,7,8]
    for num in numList:
        # yield 语句会冻结当前函数，并提交当前要生成的值
        yield num
# 对生成器进行迭代
for num in mu Generator():
    print(num,end =' ')




# 利用生成器讲一个二维的列表转换称为一维列表
nestedList = [[1,2,3],[4,3,2],[1,2,3,4,5]]
def enumList(nestedList):
    for subList in nestedList:
        for element in subList:
            yield element
print()
for num in enumList(nestedList):
    print(num, end = ' ')

print(list(enumList(nestedList))) 



# 递归生成器
# 终止条件   
nestedList = [[1,2,3],[4,3,2],20,[1,2,[4,5]],[1,2,3,4,5]]
def enumList(nestedList):
    try:
        for subList in nestedList:
            # 将多维列表中的每一个元素都传入函数，如果该元素是一个列表，则会继续迭代，
            # 否则会抛出异常，在异常处理的代码中直接返回元素值
            for element in enumList(subList):
                yield element
    except TypeError:
        yield nestedList
for num in enumList(nestedList):
    print(num, end=' ')