Day12 Python课程学习内容

1. 推导式

序号	类型
1	列表推导式
2	字典推导式
3	集合推导式
…	…

1.1 列表推导式

• 将旧列表变成新列表。

[表达式 for 变量 in 旧列表]
[表达式 for 变量 in 旧列表 if 条件]

# -------------------------------Classroom exercises-------------------------------
# 过滤长度小于等于三的人名
old_names = ['Jerry', 'Sam', 'Janice', 'James', 'Anny', 'Mike', 'Sherlock']
# 常规用法
def filter_name(names):
	new_names = []
	for name in names:
		if len(name) > 3:
			new_names.append(name)
	return new_names

new_names = filter_name(old_names)
print(new_names)
# ['Jerry', 'Janice', 'James', 'Anny', 'Mike', 'Sherlock']
# -------------------------------Other Way-------------------------------
# 通过列表推导式
names = ['Jerry', 'Sam', 'Janice', 'James', 'Anny', 'Mike', 'Sherlock']
new_names = [name for name in names if len(name) > 3]
print(new_names)	

---

• 列表推导式是非常灵活的。

# -------------------------------Classroom exercises-------------------------------
# 当人名首字母大写
names = ['jerry', 'Sam', 'janice', 'James', 'anny', 'Mike', 'Sherlock']
new_names = [name.capitalize() for name in names if len(name) > 3]
print(new_names)	

---

# -------------------------------Classroom exercises-------------------------------
# 0-100内所有可以被3整除的
new_list = [i for i in range(1,101) if i % 3 == 0]
print(new_list)	

# -------------------------------Extention-------------------------------
# 被5整除也可被3整除
new_list = [i for i in range(1,101) if i % 3 == 0and i % 5 == 0]
print(new_list)	

---

2. 生成器

背景：
通过列表推导式我们可以创建出一个列表，但是收到计算机内存的显示值，无法创建出无限庞大的列表。当我们创建一个拥有上百万的列表的时候，将会占用我们相当大的内存空间，同样也使得计算变慢，变卡。往往我们只要访问表中几个元素即可，而剩下的就会占用相当大的内存空间，而造成浪费。

• 生成器的出现，主要是为了解决以上背景问题。实现我们想访问哪几个元素，就获取哪几个元素，从而优化内存。

# -------------------------------Classroom exercises-------------------------------
lst = [x for x in range(NUMBER)
print(lst)
'''
当NUMBER中的数值越大时，lst这个列表会越大，同样会占据计算机很大的内存。
'''

---

创建生成器
(I) 可以通过列表推导式来获得生成器。

# -------------------------------Classroom exercises-------------------------------
# 获得 0 - 10 之内分别与3相乘的列表
new_lst = [x * 3 for x in range(11)]
print(new_lst) # [0, 3, 6, 9, 12, 15, 18, 21, 24, 27, 30] # list 类型
# 以上列表推导式已经使用相当大的内存。

#----------------------------------Dividing line----------------------------------
new_lst = (x * 3 for x in range(11))
print(new_lst)# <generator object <genexpr> at 0x0000000002F60780>
''' generator 就是生成器'''

***如何使用生成器！！！！***

• 方式一 : 调用 __next__() 方法来得到元素

new_lst = (x * 3 for x in range(11))
print(new_lst.__next__()) # 0
print(new_lst.__next__()) # 3

• 方式二 使用函数 next()

new_lst = (x * 3 for x in range(11))
print(next(new_lst)) # 0
print(next(new_lst)) # 3

---

由上述可见，无论是__next__() 还是next()都是重复在用，所以我们可以使用for 或 while 来得到你想要的个数。

---

(II) 利用函数的方式来得到生成器。
只要函数中出现 yield，那么这个函数就为生成器函数。

# -------------------------------Classroom exercises-------------------------------
def num():
	number = 0
	while True:
		number += 1
		print(number)
num()
# 无限循环,消耗内存和Cpu
# ----------------------------------Dividing line----------------------------------
# 使用yield生成生成器
def num():
	number = 0
	while True:
		number += 1
		yield number # yield和return相同，返回一个值。
r = num() 
print(r) # <generator object num at 0x0000000002F7E308>
print(next(r))
print(r.__next__())

---

总结：生成器可以解决列表推导式占用内存的问题。

---

3.迭代器

迭代：获取元素的一个过程

• 可迭代对象有哪些？

1. 列表(list)、集合(set)、元组(tuple)、字符串(string)、字典(dict)…
2. 生成器(generator)

• 如何判断一个对象是否是可迭代对象？
  答：使用 isinstance() 函数来检查一个对象是否是另外一个对象的实例。

# -------------------------------Classroom exercises-------------------------------
a = 1
print(isinstance(a, int)) # True 说明a为int类型的一个实例。
b = '1'
print(isinstance(b, int)) # False 说明b不为int类型的一个实例。
print(isinstance(b, str)) # True 说明b为str类型的一个实例。
# ----------------------------------Dividing line----------------------------------

from collections import Iterable 

lst = [1,2,3,4,5] # 列表 list
print(isinstance(lst, Iterable)) #True 说明列表为可迭代对象
# 在Iterable报错情况下，把鼠标放到 Iterable 上，直接Alt + Enter。
print(isinstance('123', Iterable)) # True 说明字符串为可迭代对象
print(isinstance(123, Iterable)) # False 说明整数不为可迭代对象

g = (x + 1 for x in range(5)) # 生成器 
print(isinstance(g, Iterable)) # True 说明生成器为可迭代对象

• 何为迭代器(Iterable)？
  答：可以被next()函数调用，并不断返回下一个值的对象称之为迭代器。

---

可迭代对象并不一定是迭代器

# ----------------------------------Dividing line----------------------------------
# 列表是可迭代对象，但并不是迭代器。
lst = [1,2,3,4,5]
print(next(lst)) # 用next()测试 
'''
	print(next(lst))
TypeError: 'list' object is not an iterator''' # 说明list列表不为可迭代器。
# 元组
tup = (1,2,3,4,5)
print(next(tup))
'''
	print(next(tup))
TypeError: 'tuple' object is not an iterator''' # 说明tuple元组不为可迭代器。
# 字典
dct = {'a':1, 'b':2, 'c':3, 'd':4, 'e':5}
print(next(dct))
'''
	print(next(dct))
TypeError: 'dct' object is not an iterator''' # 说明dict字典不为可迭代器。
# 集合
st = {1,2,3,4,5}
print(next(st))
'''
	print(next(st))
TypeError: 'st' object is not an iterator''' # 说明set集合不为可迭代器。
# 字符串
string = '12345'
print(next(string))
'''
	print(next(string))
TypeError: 'string' object is not an iterator''' # 说明str字符串不为可迭代器。

# -------------------------------Classroom exercises-------------------------------
# 使用iter()转换成迭代器
lst = [1,2,3,4,5]
lst = iter(lst) # 通过 iter()函数将一个迭代对象，转换成迭代器。
print(next(lst)) # 1
print(next(lst)) # 2

tup = (1,2,3,4,5)
tup = iter(tup)
print(next(tup)) # 1
print(next(tup)) # 2
# 字典返回的是key值。
dct = {'a':1, 'b':2, 'c':3, 'd':4, 'e':5}
dct = iter(dct)
print(next(dct)) # a
print(next(dct)) # b

st = {1,2,3,4,5}
st = iter(st)
print(next(st)) # 1
print(next(st)) # 2

string = '12345'
string = iter(string)
print(next(string)) # 1
print(next(string)) # 2

---

总结：
生成器是迭代对象为特殊迭代器的一种，列表、字符串等迭代对象并不是迭代器，如果列表、字符串等要转换成迭代器，要用到 iter()函数。

---

4. 面向对象的简介

程序在运行当中，所有的数据都存到内存当中的。

• 何为对象？
  对象就是内存中专门用来存储指定的数据的一块区域。

• 对象简介
  对象实际上就是一个容器，专门用来存储数据的容器。

• 对象结构
  id(标识)
  type(类型) 标识当前对象所属的一个类型 类型据定了对象有哪些功能
  value(值) 对象中具体存储的数据

• python就是一门面向对象的语言

举例：
1.妈妈穿衣服穿鞋出门
2.妈妈骑电瓶车
3.妈妈到超市门口放好电动车
4.妈妈买瓜
5.妈妈付款
6.妈妈骑电瓶车回家
7.妈妈到家给孩子吃瓜

• 面向过程↑

  • 面向过程在程序当中把整个的逻辑分解成一个一个小的步骤去完成。 如同上面的妈妈买瓜给孩子吃的一步步过程，就是面向过程。
  • 这种编写程序的方式非常符合人的逻辑思维。
  • 这种编程方式往往复用性比较低，往往只适用于一个功能。

• 面向对象

  • 面向对象编写的代码维护容易，复用容易。但不太符合人的逻辑思维，编写起来麻烦。 如：孩子妈妈买瓜给孩子吃。

---

5. 类(class)

• int、str、float、list、tuple… 这些都是python内置的对象

• 在开发的时候如果我们只用Python提供的对象是不能够满足我们的需求的，这个时候要自定义对象。

• 我们也称对象是类的实例(isinstance)

语法
class 类名([父类]):
	代码块

# -------------------------------Classroom exercises-------------------------------
# 定义简单类(class)
class MyClass:
	pass
print(MyClass) # <class '__main__.MyClass'>
# class 表示其类型
# __main__ 表示当前文件为主文件，该主文件内的Myclass

mc = MyClass() 
# mc是Myclass这个类创建出来的对象，mc是MyClass类的实例。

# 使用isnstance()检查一个对象是否是另外一个对象的实例
print(isinstance(mc, MyClass)) # Ture 证明 mc 为 MyClass 的一个实例
# 创建其他实例
mc2 = MyClass()
print(isinstance(mc2, MyClass)) # Ture 证明 mc2 为 MyClass 的一个实例。
mc3 = MyClass() 
print(isinstance(mc3, MyClass)) # Ture 证明 mc3 为 MyClass 的一个实例。
mc4 = MyClass() 
print(isinstance(mc4, MyClass)) # Ture 证明 mc4 为 MyClass 的一个实例。

print(isinstance(123, MyClass)) # False 证明 123 不为 MyClass 的一个实例。
print(isinstance(mc3, int)) # False 证明 mc3 不为 mc3 的一个实例。



print(id(MyClass), type(MyClass)) # 46528376 <class 'type'>
# 由此可见类是type类型的对象，定义类其实就是定义一个type类型的对象。

'''
向对象中添加变量，对象中的变量称之为属性
'''
'''
语法 
对象.属性名 = 属性值
'''
mc.name = 'Sam'
print(mc.name) # Sam 说明属性值添加到mc当中去了。
print(mc2.name) 
'''
	print(mc2.name) 
AttributeError: 'MyClass' object has no attribute 'name'
''' # 说明属性值不在mc2中
# 若要在mc2中添加属性值
mc2.name = 'Janice'

类的定义

类和对象都是对现实生活中事物的抽象
实际上所有的事物都是两部分组成
1.数据（属性）
2.行为（方法）

在类的代码块当中，我们就可以定变量和函数
在类定义的变量，我们称之为属性（或者说是所有实例的公共属性）

# -------------------------------Classroom exercises-------------------------------
# 创建一个人
class Person: # Person为类对象
	pass
p1 = Person() # p1为实例化对象
p2 = Person() # p2为实例化对象
# ----------------------------------Dividing line----------------------------------

class Person:
	name = 'Sam' # 公共属性，所有实例都可以访问
	def speak(a):
		print('hello')
p1 = Person()
p2 = Person()
print(p1.name, p2.name) # Sam Sam 
# 调用方法 对象.方法名()
# 如果为函数调用，函数有几个形参，则需要传递多少实参。
# 如果为方法调用，默认传递一个参数，故方法中至少定义一个形参。

p1.speak()# 如果不在类的方法，def speak()的括号内不添加形参。
'''
	p1.speak()
TypeError: speak() takes 0 positional arguments but 1 was given
''' # 需要一个参数
# 故要在def speak()的括号内添加一个形参。例如def speak(a)

---

总结：
类其实也为一个对象，是一个用来创建对象的对象。
类是type类型的对象，定义类其实就是定义一个type类型的对象。
我们可以向类对象中添加变量和函数，其中类内变量称为属性，类内的函数称之为方法。并且类中的属性和方法都是共用的。
注意：类中添加的方法，会默认传递一个参数（self），并且其他可以，比如a,b,c…

实例是如何访问类的

class Person:  # 创建一个类对象，类的名称为 Person
	name = 'Sam' # 类当中命名
person1 = Person() # 创建实例对象 Person1
person2 = Person() # 创建实例对象 Person2

person1.name = 'Janice' # person1添加person1.name = 'Janice'
print(person1.name) #  Janice	打印person.name1
print(person2.name) #  Sam  	打印person.name2

其中逻辑：
打印 person1.name 的时候，实例 person1 访问自身的 name ，并返回 ‘Janice’。
而打印 person2.name 的时候，实例 person2 访问自身的 name, 并没有值，则返回 Person 类对象中的 name 值 ‘Sam’。

当我们调用一个对象的属性石，解析器会寻找当前对象中寻找是否含有该属性。
1.如果有则返回自身的属性值，并返回自身对象的属性值
2.如果没有则找类对象中的属性值，并返回类当中的属性值。
3.如果类对象中也没有则报错