【python】语言学习笔记--用来记录总结

请问以下变量哪些是tuple类型：

 a = ()
 b = (1)
 c = [2]
 d = (3,)
 e = (4,5,6)

answer
 在Python中，元组（tuple）是由逗号分隔的一组值组成的有序序列，通常用圆括号括起来。让我们逐个检查变量，看哪些是元组类型：
a = ()：这是一个空元组，是元组类型。
b = (1)：这是一个包含一个整数值的表达式，而不是元组类型。
c = [2]：这是一个包含一个整数值的列表，而不是元组类型。
d = (3,)：这是一个包含一个整数值的元组，逗号告诉Python这是一个元组。
e = (4,5,6)：这是包含三个整数值的元组。
所以，元组类型的变量是 a、d、e。

字符串格式化的三种方法

# 这里要注意，对应不上str的类型需要通过str方法转一下，python是强类型语言，不支持类型隐式转换
print('Name: ' + p.name + ', Age: ' + str(p.age) + ', Sex: ' + p.sex) 

content = 'Name: %s, Age: %i, Sex: %c' % (p.name, p.age, p.sex)
print(content)

class Person:
    def __init__(self):
        self.name = 'JarvisMa'
        self.age = 22
        self.sex = 'm'
    def __str__(self):
        return 'Name: {user.name}, Age: {user.age}, Sex: {user.sex}'.format(user=self)

print('{0}, {1}, {0}'.format(1, 2))
# 输出：1, 2, 1，这里的 {1} 表示第二个参数

python允许对实例变量绑定任务数据

class Student(object):
    def __init__(self, name, score):
        self.name = name
        self.score = score

    def get_grade(self):
        if self.score >= 90:
            return 'A'
        elif self.score >= 60:
            return 'B'
        else:
            return 'C'

>>> bart = Student('Bart Simpson', 59)
>>> lisa = Student('Lisa Simpson', 87)
# 绑定新的属性
>>> bart.age = 8
>>> bart.age
8
# 没有绑定新的属性，所以报错
>>> lisa.age
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
AttributeError: 'Student' object has no attribute 'age'

• 外部可以随意的改变属性值
• 封装性不足

如何让内部属性不被外部访问？

1. 内部属性不被外部访问，可以把属性的名称前加上两个下划线__，在Python中，实例的变量名如果以__开头，就变成了一个私有变量（private），只有内部可以访问，外部不能访问
2. 在Python中，变量名类似__xxx__的，也就是以双下划线开头，并且以双下划线结尾的，是特殊变量，特殊变量是可以直接访问的，不是private变量
3. 不能直接访问__name是因为Python解释器对外把__name变量改成了_Student__name，所以，仍然可以通过_Student__name来访问__name变量

• 通过getter和setter方法来修改属性
• Python本身没有任何机制阻止你干坏事，一切全靠自觉

python函数传参类型和顺序

• 位置参数
• 默认参数：
• 可变参数：
  • 定义可变参数和定义一个list或tuple参数相比，仅仅在参数前面加了一个*号。
  • 在函数内部，参数numbers接收到的是一个tuple
  • Python允许你在list或tuple前面加一个*号，把list或tuple的元素变成可变参数传进去
• 关键字参数
  • extra表示把extra这个dict的所有key-value用关键字参数传入到函数的kw参数，kw将获得一个dict，注意kw获得的dict是extra的一份拷贝，对kw的改动不会影响到函数外的extra
• 命令关键字参数
  • 限制关键字参数的名字，就可以用命名关键字参数
  • 命名关键字参数需要一个特殊分隔符*，*后面的参数被视为命名关键字参数
  • 如果函数定义中已经有了一个可变参数，后面跟着的命名关键字参数就不再需要一个特殊分隔符*了
  • 命名关键字参数必须传入参数名，这和位置参数不同
  • 命名关键字参数可以有缺省值
• 参数组合：
  • 必选参数、默认参数、可变参数、命名关键字参数和关键字参数

列表生成式和生成器区别？

• 生成器的计算是惰性的，这里注意和生成式区别是()

>>> L = [x * x for x in range(10)]
>>> L
[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]
>>> g = (x * x for x in range(10))
>>> g
<generator object <genexpr> at 0x1022ef630>


# 定义一个函数为生成器
# yield+next关键字

def fib(max):
    n, a, b = 0, 0, 1
    while n < max:
        yield b
        a, b = b, a + b
        n = n + 1
    return 'done'

可以作用for循环的数据结构有那些？

1. 一类是集合数据类型，如list、tuple、dict、set、str等；
2. 一类是generator，包括生成器和带yield的generator function。
3. 这些可以直接作用于for循环的对象统称为可迭代对象：Iterable。

Iterator 和Iterable的区别？

可以使用isinstance()判断一个对象是否是Iterable对象
可以使用isinstance()判断一个对象是否是Iterator对象

>>> from collections.abc import Iterator
>>> isinstance((x for x in range(10)), Iterator)
True
>>> isinstance([], Iterator)
False
>>> isinstance([], Iterable)
True
# 可以通过iter函数，将其变成Iterator对象
>>> isinstance(iter([]), Iterator)
True

动态绑定方法

第一种情况，对于实例\

>>> def set_age(self, age): # 定义一个函数作为实例方法
...     self.age = age
...
>>> from types import MethodType
>>> s.set_age = MethodType(set_age, s) # 给实例绑定一个方法
>>> s.set_age(25) # 调用实例方法
>>> s.age # 测试结果
25
# 新的实例不会绑定上
>>> s2 = Student() # 创建新的实例
>>> s2.set_age(25) # 尝试调用方法
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
AttributeError: 'Student' object has no attribute 'set_age'

第二中情况，对于class

>>> def set_score(self, score):
...     self.score = score
...
>>> Student.set_score = set_score

限制实例的属性，不让其动态添加

• __slots__定义的属性仅对当前类实例起作用，对继承的子类是不起作用的

class Student(object):
    __slots__ = ('name', 'age') # 用tuple定义允许绑定的属性名称

@Property注解

# demo1
class Stu:
    
    @property
    def score(self):
        return self.__score

    # @score.setter
    # def score(self, val):
    #     self.__score = val

def test1():
    stu = Stu()
    stu.score = 12 #'score' of 'Stu' object has no setter
    print(stu.score)

# demo2
class Stu:
    
    @property
    def score(self): #1
        return self._score

    @score.setter
    def score(self, val): #2 
        if val > 10:
            raise ValueError("error")
        self._score = val
        
    @property
    def __prompt_type(self) -> str:
        """Return the prompt type key."""
        return "prompt"


def test1():
    stu = Stu() 
    stu.score = 9 # 调用 1
    print(stu.score) # 调用 2
    print(stu.__prompt_type) #error 方法和属性一样，通过下划线来控制访问的权限
    

if __name__ == "__main__":
    test1()

python定制列

• len()方法我们也知道是为了能让class作用于len()函数。
• 直接显示变量调用的不是__str__()，而是__repr__()，两者的区别是__str__()返回用户看到的字符串，而__repr__()返回程序开发者看到的字符串，也就是说，__repr__()是为调试服务的(就是在交互式中显示)
• 要表现得像list那样按照下标取出元素，需要实现__getitem__()方法：
• 如果一个类想被用于for … in循环，类似list或tuple那样，就必须实现一个__iter__()方法，该方法返回一个迭代对象，然后，Python的for循环就会不断调用该迭代对象的__next__()方法拿到循环的下一个值，直到遇到StopIteration错误时退出循环
• 只有在没有找到属性的情况下，才调用__getattr__，已有的属性，比如name，不会在__getattr__中查找
• 定义一个__call__()方法，就可以直接对实例进行调用

python定义枚举类

直接看demo

from enum import Enum, unique

# method1
Month = Enum('Month', ('Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec'))

# method2 commend
@unique
class Weekday(Enum):
    Sun = 0 # Sun的value被设定为0
    Mon = 1
    Tue = 2
    Wed = 3
    Thu = 4
    Fri = 5
    Sat = 6
    
print(Weekday.Mon)
print(Weekday(1)) # 既可以用成员名称引用枚举常量，又可以直接根据value的值获得枚举常量

for name, member in Weekday.__members__.items():
    print(name, '=>', member)