Python3 进阶教程（新版）_技术笔记

慕田峪6554729 2024-10-23

li=['bob', 'about', 'Zoo', 'Credit']

def f (x):
return li[0]

l=sorted(li,key=f)
print(l)

0赞 · 0采集
慕田峪6554729 2024-10-23

li=list(range(1,101))
print(li)
def f(x):
return (x**0.5) % 1 == 0

for i in filter (f,li):
print(i)

0赞 · 0采集
慕田峪6554729 2024-10-23

li=['lalice', 'BOB', 'CanDY']

def f(s):
return s.capitalize()

for i in map(f,li):
l=list(map(f,li))
print(l)

0赞 · 0采集
慕田峪6554729 2024-10-22

#请参考Student类，编写Teacher类，老师拥有任教某个科目的属性。

class Students:
def __init__(self, name, gender,score ):
self.name = name
self.gender = gender
self.score = score

class Taecher (Students):
def __init__(self,name,gender,score,account):
super().__init__(name,gender,score)
self.account=account

def get_info (self):
return self.name,self.gender,self.score,self.account
tt=Taecher("张三","女",90,"语文")

print(tt.get_info())

0赞 · 0采集
慕田峪6554729 2024-10-21

#果将类属性count改为私有属性__count，则外部无法获取__count，但是可以通过一个类方法获取，请编写类方法获得__count值。

class Animal(object):
__count= 999
def __init__(self, name, age):
self.name = name
self.age = age

@classmethod
def set_count (cls, new_count):
cls.__count=new_count

@classmethod
def get_count(cls):
return cls.__count

print(Animal.get_count())

Animal.set_count(9868)
print(Animal.get_count())

在类上调用方法

0赞 · 0采集
慕田峪6554729 2024-10-21

#Animal类的age、name、localtion定义成私有属性，并定义对应的方法修改和获取他们的值。 class Animal : def __init__(self,name,age,localtion): self.__name=name self.__age=age self.__localtion=localtion def get_name (self): return self.__name def change_name (self,new_name): self.__name=new_name def get_age (self): return self.__age def change_age (self,new_age): self.__age=new_age def get_location (self): return self.__localtion def change_localtion(self,new_localtion): self.__localtion=new_localtion dog=Animal('dog',88,'郑州') print(dog.get_name(),dog.get_location()) dog.change_localtion('北京') print(dog.get_name(),dog.get_location())

0赞 · 0采集
慕田峪6554729 2024-10-21

# 实例私有属性
class Animal(object):
    def __init__(self, name, age):
        self.name = name
        self._age = age

dog = Animal('wangwang',8)
print(dog.name) # ==> wangwang
print(dog._age) # ==> 1#不能从外部访问私有属性

0赞 · 0采集
慕田峪6554729 2024-10-21

请给 Animal类添加一个类属性 count，每创建一个实例，count 属性就加 1，这样就可以统计出一共创建了多少个 Animal的实例。

class Animal ():
count =0
def __init__(self,name,age):
self.name=name
self.age=age
count+=1

dog= Animal ('dog',2)
cat= Animal ('cat',6)
print(dog.name,dog.age)
print(cat.name,cat.age)

0赞 · 0采集
慕田峪6554729 2024-10-21

class Animal ():
    def __init__(self,name,age)
    self.name=name
    self.age=age
dog=Animal('dog',2)
cat=Animal('cat',6)
print(dog.name,dog.age)
print(cat.name,cat.age)

0赞 · 0采集
慕田峪6554729 2024-10-21

class Animals() :
dog=Animal()
cat=Animal()

0赞 · 0采集
子夜2023 2024-10-11

1.类的私有属性以__开头，无法通过外部访问，只能通过内部方法访问，为了保护类或实例属性不被外部污染而设计的。

0赞 · 0采集
慕姐1230071 2024-10-01

str = "Hello"
my_list = [str]
print(my_list) # 输出: ['Hello']

str = "Hello"
as_item_list = list(str)
print(as_item_list) # 输出: ['H', 'e', 'l', 'l', 'o']

0赞 · 0采集
子夜2023 2024-09-27
4-4 Python类的数学运算
1. 如何理解def __add__(self, r):
  return Rational(self.p * r.q + self.q * r.p, self.q * r.q)
  >>> r1 = Rational(1, 2)
  >>> r2 = Rational(2, 3)
  >>> print(r1 + r2)
思路过程：
不理解r是什么，后面经过查找，代码存在r1+r2时才会调用__add__()函数，此时self.p和self.q指的是r1的p和q，而r.p和r.q指的是r2.p和r2.q
也就是 (1*3+2*2)/2*3 有理数的答案
0赞 · 0采集

远航扬帆_2680 2024-09-26

class Rational(object):
    def __init__(self, p, q):
        self.p = p
        self.q = q
    def __add__(self, r):
        return Rational(self.p * r.q + self.q * r.p, self.q * r.q)
    def __str__(self):
        return '{}/{}'.format(self.p, self.q)
        
    
r1 = Rational(1, 2)
r2 = Rational(2, 3)
r3 = Rational(1, 6)
print(r1+r2)
print(r1.__add__(r2))

重载运算符：

r1+r2 和

r1.__add__(r2) 相同

0赞 · 0采集

远航扬帆_2680 2024-09-26

class Fib(object):
    def __init__(self,num):
        self.num=num
    
    def __len__(self):
        return len(self.num)

f = [0,1,1,2,3,5,8,13,21,34]
f_ = Fib(f)

print(f)
print(len(Fib(f)))

Fib是一个类

f_ 是这个类的一个实例，等同于Fib(f)

f 是一个列表，也是f_ 的属性

0赞 · 0采集

远航扬帆_2680 2024-09-23

私有属性从类的内部进行访问

第5行

class Animal(object):
    def __init__(self,name,age):
        self.name=name
        self.__age=age
        print(self.__age)
dog=Animal('D',5)

0赞 · 0采集

远航扬帆_2680 2024-09-23

1，实例属性的优先级高于类属性
2，通过实例可以访问类属性，但不能修改类属性
3，类属性私有化之后，不能从外部访问，只能在类内部访问

0赞 · 0采集
慕圣3512714 2024-09-19

class Animal(object):
    __localtion = 'Asia'
    __count = 0
    def __init__(self, name, age):
        Animal.__count += 1
        self.name = name
        self.age = age

    @classmethod
    def set_localtion(cls, localtion):
        cls.__localtion = localtion

    @classmethod
    def get_localtion(cls):
        return cls.__localtion

    @classmethod
    def get_count(cls):
        return cls.__count

print(Animal.get_localtion()) # ==> Asia
Animal.set_localtion('Afica')
print(Animal.get_localtion()) # ==> Africa
print(Animal.get_count()) # ==> 0
cat = Animal('Huamao',2)
print(Animal.get_count()) # ==> 1

0赞 · 0采集
慕圣3512714 2024-09-19

class Animal(object):
    def __init__(self, name, age, localtion):
        self.__name = name
        self.__age = age
        self.__localtion = localtion

    def get_info(self):
        return 'name = {}, age = {}, localtion = {}'.format(self.__name, self.__age, self.__localtion)
    def set_info(self,name,age,localtion):
        self.__name = name
        self.__age = age
        self.__localtion = localtion

dog = Animal('wangwang', 1, 'GuangDong)
print(dog.get_info())
dog.set_info('cat',2,'GuiYang')
print(dog.get_info())

0赞 · 0采集
慕圣3512714 2024-09-19

class Animal(object):
    localtion = 'Asia'
    count = 0
    def __init__(self, name, age):
        Animal.count += 1
        self.name = name
        self.age = age

0赞 · 0采集
weixin_幕布斯2038485 2024-09-07

在Python中初次操作文件可能会尝试先读file.white()后写file.read(),结果会发现明明已经写入数据，但读出内容依然为空的问题。

如下例：

file = open('./a.txt', mode="a+", encoding="utf8")
file.write("123456")
str = file.read()
print(str)
# 读出内容为空
# a.txt 内容为123456
1
2
3
4
5
6
造成这种问题的原因是，当写入操作完成时，文件光标处于文件末尾处；接着继续执行读取操作，系统从光标处向后读取，但光标已处于末尾，所以读出内容为空。

该问题有两种解决方案：

方法一：规范代码，将读取操作与写入操作分类，在一种操作执行结束后应及时关闭文件指针file.close()。使用这种方法可以是文件安全有效，不会被其他操作影响预计效果。
如下：

# 写入
file = open('./a.txt', mode="w", encoding="utf8")
file.write("123456")
file.close()
# 读取
file = open('./a.txt', mode="r", encoding="utf8")
str = file.read()
print(str)
# 输出为 123456
# a.txt 123456
1
2
3
4
5
6
7
8
9
10
方法二：使用seek()方法移动光标至指定位置

file.seek(offset,whence=0)

offset：偏移量，即需要移动偏移的字节数。

whence：要从哪个位置开始偏移，默认值为0；0代表从文件开头开始算起，1代表从当前位置开始算起，2代表从文件末尾算起。

同时whence也可以使用常量名表示(需要引入os模块)：
whence常量:
os.SEEK_SET: 0 相对文件起始位置
os.SEEK_CUR: 1 相对文件的当前位置
os.SEEK_END: 2 相对文件的结束位置

对于本问题，可以在写入之后将光标从新移动至文件开头位置，然后执行读取操作

file = open('./a.txt', mode="a+", encoding="utf8")
file.write("123456")
# 表示移动0个位置，从文件开头开始
file.seek(0, 0)
str = file.read()
print(str)
# 输出为 123456
# a.txt 123456
1
2
3
4
5
6
7
8
注意：Python3中不支持非二进制的文件光标移动位置且offset按位取值，所以非二进制文件建议只使用将光标移动到开头或末尾的功能，即offset==0,避免出现io.UnsupportedOperation: can't do nonzero cur-relative seeks或者io.UnsupportedOperation: can't do nonzero end-relative seeks的错误
————————————————

版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。

原文链接：https://blog.csdn.net/w18211679321/article/details/81451838

0赞 · 0采集
weixin_幕布斯2038485 2024-09-07

# Enter a
def say_hello(name):
print('您好呀，{}'.format(name))
print(f"你好啊，{name}")
print("宁浩呀，我是%s"%name)

say_hello("xioaming")

0赞 · 0采集
weixin_幕布斯2038485 2024-09-06

class Person(object):
    def __init__(self, name, gender):
        self.name = name
        self.gender = gender

class Student(Person):
    def __init__(self, name, gender, score):
        super(Student, self).__init__(name, gender)
        self.score = score

    def __str__(self):
        return 'Student: {}, {}, {}'.format(self.name, self.gender, self.score)
    def __repr__(self):
        return 'STUDENT: {}, {}, {}'.format(self.name, self.gender, self.score)

s = Student('Bob', 'Male', 88)

print(s)
print('%s' % s)
print('%r' % s)
print(str(s))
print(repr(s))

0赞 · 0采集
weixin_幕布斯2038485 2024-09-06

Teacher 继承 Student 时，__init__()括号中需要写被继承类的全部参数， super(Teacher, self).__init__(name, gender)报错是因为缺少了Student的score参数； t = Teacher('Alice', 'Female', 'English') Teacher继承Student的三个参数后又定义了course参数，共4个参数，这个地方少了一个参数

0赞 · 0采集

慕尼黑7050194 2024-09-03

有参数的decorator

在外面套一层专门接收参数的函数

例：

请给 @performace 增加一个参数，允许传入's'

import time
from functools import reduce

def performance(prefix):
    def performance_decorator(f):
        def fn(*args, **kwargs):
            t1 = time.time()
            f(*args, **kwargs)
            t2 = time.time()
            print('函数f运行时间是{}{}'.format(t2 - t1,prefix))
        return fn
    return performance_decorator

@performance('s')
def f(list_):
    return reduce(lambda x,y: x*y, list_)

f(list(range(1,10000)))

解释：

def performance(参数)：

def performance_decorator(函数f):

...

return performance_decorator

performance_decorator = performance(参数)

新函数 = performance_decorator(原函数)

0赞 · 0采集

慕尼黑7050194 2024-09-03

装饰器的作用：

给原函数装饰装饰变成新函数

装饰器的语法：

@+装饰器函数名

例：

编写一个decorator计算函数的运行时间

import time
from functools import reduce

def performance(f):
    def fn(*args, **kwargs):
        t1 = time.time()
        f(*args, **kwargs)   #接收函数用*args，**kwargs；在函数中用args，kwargs
        t2 = time.time()
        print('函数f运行时间是{}s'.format(t2 - t1))
    return fn

@performance
def f(list_):
    return reduce(lambda x,y: x*y, list_)

f(list(range(1,100000)))
==>函数f运行时间是2.1856231689453125s

解释：

将函数f作为参数传给函数performance
函数performance接收原函数f
在函数performance中定义新函数fn，新函数的参数用来接收原函数的参数，一般设为*args,**kwargs可接收任何形式参数
装饰原函数
返回新函数fn

0赞 · 0采集

慕尼黑7050194 2024-09-03

def calc_sum(list_):
    def lazy_sum():
        return sum(list_)
    return lazy_sum
f = calc_sum([1, 2, 3, 4])
f()
==>10

闭包：

内层函数引用外层函数的变量（参数也算是变量），最后外层函数返回内层函数

那么这个内层函数就是一个闭包（类似打包返回）

错误写法：

# 希望一次返回3个函数，分别计算1x1,2x2,3x3:
def count():
    fs = []
    for i in range(1, 4):
        def f():
             return i*i
        fs.append(f)
    return fs

f1, f2, f3 = count() #内层函数只被定义还没运行，此时外层函数运行完毕i=3
f1()==>9   #运行内层函数
f2()==>9
f3()==>9

正确写法:

def count():
    fs=[]
    for i in range(1,4):
        def g(j=i):       #为内层函数设置形参默认值
            return j*j
        fs.append(g)
    return fs

f1,f2,f3=count()
print(f1(),f2(),f3())

在Python中，函数形参默认值是指在定义函数时为形参指定的默认值，在调用函数时，如果没有为该形参提供实际的参数值，函数会使用默认值

0赞 · 0采集

慕尼黑7050194 2024-09-03
Python在函数内部定义子函数，并把子函数返回
```
def f():
    def g():
        return ...
    return g
x = f()
x()
```
函数名g就是指向函数g的变量
不加小括号就只是一个变量，加上小括号才能调用函数
0赞 · 0采集
慕尼黑7050194 2024-09-02
匿名函数
lambda 参数 : 表达式
可以有多个参数，但只能有一个表达式，返回值就是表达式的结果

例：
```
map(lambda x:x*x,[1,2,3,4])
reduce(lambda x,y:x*y,[1,2,3,4])
sorted(['bob', 'about', 'Zoo', 'Credit'],key=lambda x:x.lower())
```
0赞 · 0采集
慕尼黑7050194 2024-09-02
sorted(list, (key=函数对象f, reverse=True)) 默认从小到大排序
函数f的作用：
接受待排序列表的元素作为参数传入函数f，并返回真正需要排序的字段
例1：
（姓名，成绩）按成绩进行排序
```
def f(item):
    return item[1]
print(sorted([('Alice', 72), ('Candy', 90), ('Bob', 62)],key=f))
==>[('Bob', 62), ('Alice', 72), ('Candy', 90)]
```
例2：
对字符串忽略大小写进行排序
```
def f(item):
    return item.lower()
print(sorted(['bob', 'about', 'Zoo', 'Credit'],key=f))
==>['about', 'bob', 'Credit', 'Zoo']
```
0赞 · 0采集

数据加载中...