Python学习第二周总结

python学习第二周总结

函数
作用域 - LEGB

模块

字符串

列表

元组

集合

内存管理

面向对象编程

函数

函数中括号里可以传入参数可以是1个可以是多个也可以不传入参数，同时可以给参数赋默认值，这样当调用时没有传入参数也可以保证函数正常运行‘args’表示可变参数，可以传入多个参数。函数最后可以有一个返回值，也可以没有，如果需要将列表中的参数传入进去，需要在列表前加一个‘*’

def f(*args):
total = 0
for val in args:
total += val
return total

mylist = [1, 2, 3, 4]
print(f(*mylist))

我们可以把相对独立的将来还可以使用的模块写成函数，就可以直接调用。

作用域 - LEGB

L：局部作用域

E：嵌套作用域

G：全局作用域

B：内置作用域

函数搜索的顺序是L -> E -> G -> B

a = 100 # 全局变量
def f():
a = 200 #局部变量
print(a) # 输出200
def g():
b = 'hello'
print(a) # 输出100
f()

a = 100 # 全局变量
def f():
global a # 直接调用全局变量
a = 200 #全局变量
b = 'hello'
print(a) # 输出20
def g():
nonlocal b # 直接调用局部变量
b = 'hi'
print(b)
print(a) # 输出200

模块

import **** # 调用****模块
import **** from **** # 从****模块里导入****这个函数
import **** as ** # 使**这个名称表示****这个模块

字符串

通过一段代码介绍字符串的基本使用方法：

s = 'aasddcAAS'
S.lowercase()
S.capitalize()   #首字母大写
S.lower()      #转小写
S.upper()      #转大写
S.swapcase()    #大小写互换
S.split(str, ' ')  #将string转list，以空格切分
S.join(list, ' ')  #将list转string，以空格连接

列表

通过一段代码介绍列表的基本使用方法：

mylist = [x * 2 for x in range(1, 5)] # 为[2, 4, 6, 8]
mylist = mylist + [20, 30]
L.append(var)  #追加元素
L.insert(index,var)
L.pop(var)   #返回最后一个元素，并从list中删除之
L.remove(var)  #删除第一次出现的该元素
L.count(var)  #该元素在列表中出现的个数
L.index(var)  #该元素的位置,无则抛异常
L.extend(list) #追加list，即合并list到L上
L.sort()    #排序
L.reverse()   #倒序
list 操作符:,+,*，关键字del
a[1:]    #片段操作符，用于子list的提取
[1,2]+[3,4] #为[1,2,3,4]。同extend()
[2]*4    #为[2,2,2,2]
del L[1]  #删除指定下标的元素
del L[1:3] #删除指定下标范围的元素
L1 = L   #L1为L的别名，类似于将L的内存地址赋给了L1
L1 = L[:]  #L1为L的克隆，即另一个拷贝。
print(mylist)

tips：列表里尽量存放一直数据类型的数据，如果要存储不同的数据类型且数据类型不变，尽量使用元组

元组

即数据不可变的列表，创建一个元组所需要消耗的控件时间都远远小于列表

s = (1, 2, 3, 4)

集合

Python中的集合类似于数学中的集合，集合中无法存储重复的元素

def main():
set1 = {1, 2, 3, 4, 5, 1, 2, 3, 4, 5}
print(set1)
set1.add(7)
print(set1)
set2 = {1, 3, 5, 7, 9}
print(set1.intersection(set2))  # 输出交集
print(set1.union(set2))  # 输出并集
print(set1.difference(set2))  # 输出差集
print(set1.symmetric_difference(set2))  # 输出对称差集
if 3 in set1:
set1.remove(3)  # 先判断一个元素是否在集合中，如果在就删除
for val in set1:  # 输出集合中的元素
print(val)
print(set1.issuperset(set2))  # 判断set1是不是set2的超集
print(set1.issubset(set1))  # 判断set1是不是set2的子集
list1 = list(set1)  # 将列表转化为集合
tuple1 = tuple(set1)  # 将集合转化为元组
set3 = set(list1)  # 将列表转化为数组
if __name__ == '__main__':
main()

tips：集合是无序的无法使用下表运算，如果删除的元素在集合中不存在就会报错，所以在删除集合的元素之前一般要判断改元素是否存在于集合中

内存管理

栈：变量 - 地址 - 对象的引用

堆：真正的对象

id()：获取对象地址

is：判断是不是同一个对象

sys.getsizeof：返回对象所占空间大小

sys.getrefcount：查看对象的引用计数

静态区

bb57

tips：Python中使用的是自动内存管理，有垃圾回收机制。

面向对象编程

面向对象即是将电脑视为一个对象的合集（类），我们需要向这个对象发出指令的时候就调用对象内置的一些函数，当我们执行这些函数的时候就相当于对对象发出了消息，对象接收到消息，如果有匹配的函数那么他就会执行相应的动作。

类就是把一切东西看成一个个对象，比如人，车，面包，等等，

然后把这些对象拥有的属性变量，比如年龄，民族，工作地点，变质期，寿命，

还有操作这些属性变量的函数打包成一个类来表示，

这个类的一个实例就是一个对象，比如人这个类包含一些属性，比如年龄，名字，住址等，

他还有一些对别人告诉这些属性的功能，比如：说，看，走等！

举一个简单的例子

"""
step 1
定义类：
类是对象的蓝图和模板，有了类就可以创建对象
定义类需要做两件事，数据抽象和行为抽象
数据抽象 - 抽取对象共同的静态特征（找名词） - 属性
欣慰抽象 - 抽取对象共同的动态特征（找动词） - 行为
定义类的关键字 - class - 类名（每个单词首字母大写）
"""

class Student(object):

# 构造方法(构造器/构造子 - constructor)
# 调用该方法的时候不是直接使用方法的名字而是使用类的名字
def __init__(self, name = '佚名', age = 18):
self.name = name
self.age = age

# 我们定义一个方法就代表对象可以接受这个消息
# 对象的方法的第一个参数都是统一写成self
# 它代表了接受消息的对象
# 对象.消息(参数)
def study(self, course):
print('%d岁的%s正在学习%s' % (self.age, self.name, course))

def watch_av(self):
if self.age >= 18:
print('%d岁的%s正在看爱情动作片' % (self.age, self.name))
else:
print('%s我们推荐你观看退役战神卢本伟直播' % self.name)

def main():
# step 2
# 调用构造方法创建学生对象
# 实际上是调用的Student类中的'__init__'方法
stu = Student()
stu2 = Student('五五开', 17)
# step 3
# 通过给对象发消息让对象可以完成某些工作
# 解决任何问题都是通过让对象做事情
stu.study('Python程序设计')
stu2.watch_av()
print(stu.age)

if __name__ == '__main__':
main()

这是创建一个简单的学生类，同时我给了类2个方法：watch_av和study，当我向实例化的对象发送study消息的时候他就会执行这个动作，正如我代码中的注释的，创建一个对象有3步，第一步创建一个类，第二步使用构造方法构造一个对象，第三部给对象发消息让对象完成某些工作，由于Python集成了大量的类，所以我们以后可能会引用其他人已经写好的类，这也是类的一个优点，当有人创造出了一个类并且共享之后，全世界的程序猿都可以使用这个类，使整个圈子的生态环境更好，所以我们一般的面向对象的编程，都会有第二步第三步，第一步是视情况而定。

几个简单的例子：

# 设计一个数字时钟获取系统当前时间并且可以实现同步
from time import sleep
import time

class NumClock(object):
def __init__(self):
self.hr = int(time.strftime('%H'))
self.minute = int(time.strftime('%M'))
self.sec = int(time.strftime('%S'))

def run(self):
self.sec += 1
if self.sec >= 60:
self.sec %= 60
self.minute += 1
if self.minute >= 60:
self.minute %= 60
self.hr += 1
if self.hr >= 24:
self.hr %= 24

def __str__(self):
return '%.2d:%.2d:%.2d' % (self.hr, self.minute, self.sec)

def main():
clock = NumClock()
while True:
clock.run()
print(clock)
sleep(1)

if __name__ == '__main__':
main()

"""
设计一个倒计时的秒表，倒计时到0：0：0就停止
"""
from time import sleep

class NumClock(object):
def __init__(self, hr, minute, sec):
self.hr = hr
self.minute = minute
self.sec = sec

def run(self):
self.sec -= 1
if self.sec < 00:
self.sec += 60
self.minute -= 1
if self.minute < 0:
self.minute += 60
self.hr -= 1
if self.hr < 0:
self.hr += 24

def __str__(self):
return '%.2d:%.2d:%.2d' % (self.hr, self.minute, self.sec)

def main():
clock = NumClock(0, 1, 1)
while clock.sec != 0 or clock.minute != 0 or clock.sec != 0:
clock.run()
print(clock)
sleep(1)

if __name__ == '__main__':
main()

Tips：使用在class中定义方法的时候，尽量不要使用print(),input()之类的函数，因为如果使用这些函数的话，那么执行结果就只能在控制台上显示，无法显示在自己写的图形界面上，对于日后的开发肯定是不利的，推荐使用return或者yield在调用方法的时候在进行输出更佳。