Python学习笔记（Day6-Day10）

最新推荐文章于 2024-07-23 14:36:35 发布

两粒燚龘

最新推荐文章于 2024-07-23 14:36:35 发布

阅读量261

点赞数

分类专栏：笔记文章标签： python

本文链接：https://blog.csdn.net/qq_51310796/article/details/113405130

版权

笔记专栏收录该内容

3 篇文章 0 订阅

订阅专栏

Day6：函数与Lambda表达式

函数

定义：

函数以def关键词开头，后接函数名和圆括号()。
函数执行的代码以冒号起始，并且缩进。
return [表达式] 结束函数，选择性地返回一个值给调用方。不带表达式的return相当于返回None。
定义中（）内是形参
参考

Lambda表达式

使用 lambda 关键词来创建匿名函数
语法结构 lambda argument_list: expression
lambda - 定义匿名函数的关键词。
argument_list - 函数参数，它们可以是位置参数、默认参数、关键字参数，和正规函数里的参数类型一样。
: 冒号，在函数参数和表达式中间要加个冒号。
expression - 只是一个表达式，输入函数参数，输出一些值。
注意：
expression 中没有 return 语句，因为 lambda 不需要它来返回，表达式本身结果就是返回值。
匿名函数拥有自己的命名空间，且不能访问自己参数列表之外或全局命名空间里的参数。
参考

练习题

#怎么给函数编写⽂档？
在函数头（包含def关键字的那一行）的下一行用一对单引号或双引号将注释括起来。
可以使用"__doc__"或help()查看

def add (x,y):
    "求和"
    return x + y

print(add.__doc__)
#输出结果
#计算两个数的和


#怎么给函数参数和返回值注解？
def func(x: int, y: int) -> int:
#闭包中，怎么对数字、字符串、元组等不可变元素更新。
使用 nonlocal 关键字
#分别根据每一行的首元素和尾元素大小对二维列表 a = [[6, 5], [3, 7], [2, 8]] 排序。(利用lambda表达式)
a = [[6, 5], [3, 7], [2, 8]]
a = sorted(a,key=lambda i:i[0])

a = sorted(a,key=lambda i:i[-1])

#利用python解决汉诺塔问题？
def move(n, a, b, c):
    if n == 1:
        print(a, "->", c)
    else:
        print(a, "->", b)
        move(n - 1, a, b, c)
        print(b, "->", c)


move(64, "a", "b", "c")

Day7 - 8：类、对象与魔法方法

类与对象

同 c++ 类似，但是没有private、public、protected关键词，默认的成员函数和成员变量都为公开
self 关键词对应 c++ 中的 this
存在 __init__ () 的特殊方法（构造方法），该方法在类实例化时会自动调用，应该就是构造函数
公有和私有：定义私有变量只需要在变量名或函数名前加上**“__”**两个下划线
Python 严格要求方法需要有实例才能被调用，这种限制其实就是 Python 所谓的绑定概念：Python 对象的数据属性通常存储在名为.__ dict__的字典中，我们可以直接访问__dict__，或利用 Python 的内置函数vars()获取.__ dict__。

练习题

1、以下类定义中哪些是类属性，哪些是实例属性？

class C:
    num = 0
    def __init__(self):
        self.x = 4
        self.y = 5
        C.count = 6
num = 0 ，C.count = 6是类属性 
self.x = 4 self.y = 5是实例属性

2、怎么定义私有⽅法？
在变量名或函数名前加上 __ 两个下划线

3、尝试执行以下代码，并解释错误原因：

class C:
    def myFun():
        print('Hello!')
    c = C()
    c.myFun()
    myFun()的括号内应该输入self
4、按照以下要求定义一个游乐园门票的类，并尝试计算2个成人+1个小孩平日票价。

要求:

平日票价100元
周末票价为平日的120%
儿童票半价
class Ticket():
	def __init__(self,time,adult_n,child_n):
        self.time=time
        self.adult_n=int(adult_n)
        self.child_n=int(child_n)
        
    def get_price(self):
        if self.time=="weekday":
            adult_p=120
            child_p=60
        if self.time=="workday":
            adult_p=100
            child_p=50
        total_p=self.adult_n*adult_price+self.child_n*child_p
        print("总票价是：%d" %total_p )

time=input("请输入去公园的时间（weekday or workday）：")
adult_n=int(input("请输入成人数："))
child_n=int(input("请输入小孩数："))
t=Ticket(time,adult_number,child_number)
t.get_price()

魔法方法

魔法方法总是被双下划线包围，例如__init__。
魔法方法是面向对象的 Python 的一切。
魔法方法的“魔力”体现在它们总能够在适当的时候被自动调用。
魔法方法的第一个参数应为cls（类方法）或者self（实例方法）。

练习题

__new__(cls[, ...])
 在一个对象实例化的时候所调用的第一个方法，在调用__init__初始化前，先调用__new__。

__new__至少要有一个参数cls，代表要实例化的类，此参数在实例化时由 Python 解释器自动提供，后面的参数直接传递给__init__。
__new__对当前类进行了实例化，并将实例返回，传给__init__的self。但是，执行__new__，并不一定会进入__init__，只有__new__返回了，当前类cls的实例，当前类的__init__才会进入。

__init__(self[, ...]) 构造器，当一个实例被创建的时候调用的初始化方法

__str__(self):
当你打印一个对象的时候，触发__str__
当你使用%s格式化的时候，触发__str__
str强转数据类型的时候，触发__str__

__repr__(self)
repr是str的备胎
有__str__的时候执行__str__,没有实现__str__的时候，执行__repr__
repr(obj)内置函数对应的结果是__repr__的返回值
当你使用%r格式化的时候 触发__repr__

__getitem__(self, key)定义获取容器中元素的行为，相当于self[key]。

__setitem__(self, key, value)定义设置容器中指定元素的行为，相当于self[key] = value。

利用python做一个简单的定时器类

要求:

定制一个计时器的类。
start和stop方法代表启动计时和停止计时。
假设计时器对象t1，print(t1)和直接调用t1均显示结果。
当计时器未启动或已经停止计时时，调用stop方法会给予温馨的提示。
两个计时器对象可以进行相加：t1+t2。
只能使用提供的有限资源完成。
python的time库


import time


class Mytime(object):
    def __init__(self):
        self.__info = '未开始计时！'
        self.__begin = None
        self.__end = None
        self.__jg = 0

    def __str__(self):
        return self.__info

    def __repr__(self):
        return self.__info

    def start(self):
        print('计时开始...')
        self.__begin = time.localtime()

    def stop(self):
        if not self.__begin:
            print('提示：请先调用start()开始计时！')
            return
        self.__end = time.localtime()
        self.__jg = time.mktime(self.__end) - time.mktime(self.__begin)
        self.__info = '运行了%d秒' % self.__jg
        print('计时结束！')
        return self.__jg

    def __add__(self, other):#加号重载
        return '共运行了%d秒' % (other.__jg + self.__jg)


t1 = Mytime()
print(t1)
# 未开始计时！
t1.stop()
# 提示：请先调用start()开始计时！
t1.start()
# 计时开始...
time.sleep(5)
t1.stop()
# 计时结束！
print(t1)
# 运行了5秒
t2 = Mytime()
t2.start()
# 计时开始...
time.sleep(7)
t2.stop()
# 计时结束！
print(t2)
# 运行了7秒
print(t1 + t2)
# 共运行了12秒

Day9：模块与datetime模块

模块：

模块是一个包含所有你定义的函数和变量的文件，其后缀名是.py。模块可以被别的程序引入，以使用该模块中的函数等功能。这也是使用 Python 标准库的方法。

命名空间

内置命名空间（Built-in Namespaces）：Python 运行起来，它们就存在了。内置函数的命名空间都属于内置命名
空间，所以，我们可以在任何程序中直接运行它们，比如 id() ,不需要做什么操作，拿过来就直接使用了。
全局命名空间（Module：Global Namespaces）：每个模块创建它自己所拥有的全局命名空间，不同模块的全局
命名空间彼此独立，不同模块中相同名称的命名空间，也会因为模块的不同而不相互干扰。
本地命名空间（Function & Class：Local Namespaces）：模块中有函数或者类，每个函数或者类所定义的命名
空间就是本地命名空间。如果函数返回了结果或者抛出异常，则本地命名空间也结束了。

导入模块

import 模块名
from 模块名 import 函数名
import 模块名 as 新名字

if name == ‘main’

程序的入口，类似于c/c++中的main函数作用

包

包是一种管理 Python 模块命名空间的形式，采用"点模块名称"。
创建包：

创建一个文件夹，用于存放相关的模块，文件夹的名字即包的名字。
在文件夹中创建一个 init.py 的模块文件，内容可以为空。
将相关的模块放入文件夹中。
参考

练习题

1、怎么查出通过 from xx import xx导⼊的可以直接调⽤的⽅法？
当包内的__init__.py模块下有__all__列表时，则为__all__列表内定义的所有子模块。没有__all__列表时，需要看__init__.py内的代码做具体判断。
2、了解Collection模块，编写程序以查询给定列表中最常见的元素。

题目说明：

输入：language = [‘PHP’, ‘PHP’, ‘Python’, ‘PHP’, ‘Python’, ‘JS’, ‘Python’, ‘Python’,‘PHP’, ‘Python’]
输出：Python
collection模块

from collections import Counter
language = ['PHP', 'PHP', 'Python', 'PHP', 'Python', 'JS', 'Python', 'Python','PHP', 'Python']
def most_element(language):
    count = Counter(language)
    result = count.most_common(1)
    return result[0][0]
result = most_element(language)
print(result)
# Python

datetime模块

datetime 是 Python 中处理日期的标准模块，它提供了 4 种对日期和时间进行处理的类：datetime、date、time 和 timedelta。

学习链接

练习题

1、假设你获取了用户输入的日期和时间如2020-1-21 9:01:30，以及一个时区信息如UTC+5:00，均是str，请编写一个函数将其转换为timestamp：

关于时间戳timestamp

from datetime import datetime, timezone, timedelta
def to_timestamp(dt_str, tz_str):
    t,tz=dt_str,tz_str
    tz=tz.split(':')[0].split('+')
    #str转换成datetime
    t=datetime.strptime(t,'%Y-%m-%d %H:%M:%S')
    #datetime添加时区
    utc_dt=t.replace(tzinfo=timezone(timedelta(hours=int(tz[1]))))
    #datetime转换成timestamp
    return utc_dt.timestamp()    

t=to_timestamp('2015-6-1 08:10:30', 'UTC+7:00')
print(t)

2、编写Python程序以选择指定年份的所有星期日

import datetime
a=input('请输入年份:')
def all_sundays(year):
    n=int(a)
    dt1=datetime.date(n,1,1)
    dt2=datetime.date(n,12,31)
    for i in range((dt2-dt1).days+1):
        day=dt1+datetime.timedelta(days=i)
        b=day.isoweekday()
        if b==7:
            print(day)
        else:
            continue       
all_sundays(a)

Day10：文件与文件系统

~~请查阅此字典开始学习~~

练习题

1、打开中文字符的文档时，会出现乱码，Python自带的打开文件是否可以指定文字编码？还是只能用相关函数？

参考文章
使用open(path, 'r', encoding = 'utf-8')语句来打开中文字符文档

2、编写程序查找最长的单词

输入文档: res/test.txt

题目说明:

def longest_word(filename):
    with open(filename, 'r', encoding = 'utf-8') as f:
    	data = f.read().strip().split('\n')   #读取、移除首尾空格、分割每一行
    data1 = ' '.join(data).split(' ')         #连接成一行再按空格分割出单个单词
    data1.sort(key = lambda x:len(x))         #以单词长度排序
    longest = [i for i in data1 if len(i) == len(data1[-1])]  #记录最长的单词
    return longest

两粒燚龘

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Python学习笔记（Day6-Day10）

Day5：函数与Lambda表达式函数定义：函数以def关键词开头，后接函数名和圆括号()。函数执行的代码以冒号起始，并且缩进。return [表达式] 结束函数，选择性地返回一个值给调用方。不带表达式的return相当于返回None。定义中（）内是形参参考Lambda表达式使用 lambda 关键词来创建匿名函数语法结构 lambda argument_list: expressionlambda - 定义匿名函数的关键词。argument_list - 函数参数，它们可以
复制链接

扫一扫