python第二课-checkpoint
课程内容
1、 条件判断
2、 循环
3、 函数
4、 类
条件判断
if condition:
do somthing
else:
do somthing
应用题：小姐姐买水果，合计金额为32.5元，水果店搞活动，满30打九折，求小姐姐实际花费。
total_cost = 32.5
if total_cost > 30:
discount = 0.9
else:
discount = 1
total_cost *= discount
print('小姐姐的实际花费为: {}元'.format(total_cost))
小姐姐的实际花费为: 29.25元
应用题：小姐姐买水果，合计金额为32.5元，水果店搞活动，满30打九折，超过50元，打八折，求小姐姐实际花费。
total_cost = 32.5
if total_cost > 50:
discount = 0.8
elif total_cost > 30:
discount = 0.9
else:
discount = 1
total_cost *= discount
print('小姐姐的实际花费为: {}元'.format(total_cost))
小姐姐的实际花费为: 29.25元
重点
1、条件判断可以任意组合
第一层意思：elif可以有0到任意多个，else可有可无
第二层意思：条件判断可以进行嵌套
2、着重看下condition
bool(''), bool({}), bool([]) # 空字符、空字典、空列表
(False, False, False)
condition = ''
if condition:
print('True')
else:
print('False')
False
从理解的角度来讲，一个值被当作布尔值，概念上更像是有与没有的区别。
and or not
布尔型变量做运算
a = True
b = False
print('a and b is {}'.format(a and b))
print('a or b is {}'.format(a or b))
a and b is False
a or b is True
非布尔类变量做and or not运算
a = 'hello world'
b = [1,2,3]
print('a and b is {}'.format(a and b))
print('a or b is {}'.format(a or b))
a and b is [1, 2, 3]
a or b is hello world
# 非布尔型变量 and 运算
a = [1,2,3]
b = 10
print(b and a)
# 非布尔型变量 or 运算
a = 'ni hao'
b = {'apple': 100}
print(a or b)
# 非布尔型变量 not 运算，永远返回True 或False
print(not b)
[1, 2, 3]
ni hao
False
条件判断的近亲 - 断言
if not condition:
crash program
# 它的意思是：我断言肯定是这样的，如果不这样，我就崩溃
age = 19
assert age == 18,'她竟然不是18岁' # assert 为断言
---------------------------------------------------------------------------
AssertionError Traceback (most recent call last)
in
1 age = 19
----> 2 assert age == 18,'她竟然不是18岁' # assert 为断言
AssertionError: 她竟然不是18岁
循环
for 循环 - 遍历循环
while 循环 - 条件循环
costs = [3,4,25,36,62,102,33,100]
for cost in costs:
print('消费 {} 元'.format(str(cost).center(8)))
消费 3 元
消费 4 元
消费 25 元
消费 36 元
消费 62 元
消费 102 元
消费 33 元
消费 100 元
生成一个长度为20的随机列表
import random
random_numbers = []
while len(random_numbers) < 20:
random_numbers.append(random.randint(1,10))
print(random_numbers,len(random_numbers))
[4, 7, 9, 6, 1, 5, 8, 5, 1, 6, 5, 7, 5, 5, 9, 6, 5, 9, 8, 1] 20
编程建议：只要能使用 for 循环，就不要用 while 循环
import random
random_numbers = []
for i in range(20):
random_numbers.append(random.randint(1,10))
print(random_numbers,len(random_numbers))
[5, 5, 3, 5, 2, 5, 7, 5, 1, 1, 3, 7, 3, 5, 4, 5, 9, 4, 10, 4] 20
什么时候必须用while循环：当循环的条件跟数量没有关系时，只能用while
题目：往空列表中添加随机数，直到添加的数为9，则终止
random_numbers = []
while 9 not in random_numbers:
random_numbers.append(random.randint(1,10))
print(random_numbers,len(random_numbers))
[7, 2, 8, 9] 4
重点：只有一个元素的列表
问题：a = [1,2,3], b = 1, c =(b in a), 大家猜测，c是一个什么类型，它是不是一个元组？
# 死循环演示
import time
number = 0
while True:
time.sleep(1)
number += 1
print('hello world. {} '.format(number), end='\r')
hello world. 18
---------------------------------------------------------------------------
KeyboardInterrupt Traceback (most recent call last)
in
4 number = 0
5 while True:
----> 6 time.sleep(1)
7 number += 1
8 print('hello world. {} '.format(number), end='\r')
KeyboardInterrupt:
a = [1]
b = (1,) # 只是这么写为数值，如果在数值后面加上逗号，即为元组
type(a),type(b)
(list, tuple)
random_numbers
[7, 2, 8, 9]
for number in random_numbers:
if number % 2 == 0:
print('{} 是偶数'.format(number))
else:
print('{} 是奇数'.format(number))
7 是奇数
2 是偶数
8 是偶数
9 是奇数
continue 跳过
random_numbers = [2,3,4,5,6,8]
for number in random_numbers:
if number % 2 == 0:
print('{} 是偶数'.format(number))
else:
continue # 循环if语句，是输出，不是则跳过本次继续循环if语句
print('没有跳过')
2 是偶数
没有跳过
4 是偶数
没有跳过
6 是偶数
没有跳过
8 是偶数
没有跳过
跳出循环
for number in random_numbers:
if number % 2 == 0:
print('{} 是偶数'.format(number))
else:
break # 是则继续循环，不是则结束
print('没有结束')
2 是偶数
没有结束
循环中的else：如果在循环过程中，没有碰到break语句，就会执行else里的代码
random_numbers = [2,10,4,32,6,8]
for number in random_numbers:
if number % 2 == 0:
print('{} is 偶数'.format(number))
else:
break # 是则继续循环，不是则结束
print('没有结束')
else:
print('全是偶数')
2 is 偶数
没有结束
10 is 偶数
没有结束
4 is 偶数
没有结束
32 is 偶数
没有结束
6 is 偶数
没有结束
8 is 偶数
没有结束
全是偶数
for 循环可以构建推导式
所谓推导式，就是一种从一个数据序列构建另一个数据序列的方法。
random_numbers = list(range(10))
random_numbers
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
new_numbers = []
for number in random_numbers:
new_numbers.append(number * 10)
new_numbers
[0, 10, 20, 30, 40, 50, 60, 70, 80, 90]
列表推导式
new_numbers = [number * 10 for number in random_numbers]
new_numbers
[0, 10, 20, 30, 40, 50, 60, 70, 80, 90]
字典推导式
dict_number = {number: 'S' for number in random_numbers}
dict_number
{0: 'S',
1: 'S',
2: 'S',
3: 'S',
4: 'S',
5: 'S',
6: 'S',
7: 'S',
8: 'S',
9: 'S'}
tuple_number = (number * 10 for number in random_numbers)
tuple_number
at 0x000002A133208C48>
生成器
tuple(tuple_number)
(0, 10, 20, 30, 40, 50, 60, 70, 80, 90)
函数
varibal = {
'a' : 100,
'b' : 100,
'c' : 200
}
varibal['a']
100
varibal.items()
dict_items([('a', 100), ('b', 100), ('c', 200)])
[key for key, value in varibal.items() if value == 100]
['a', 'b']
函数 - 抽象概念
def get_keys(dict_varibal, value):
return [k for k, v in dict_varibal.items() if v == value]
get_keys(varibal, 100)
['a', 'b']
get_keys(varibal, 200)
['c']
函数是组织好的，可重复使用的，能够完成特定功能的代码块，他是代码块的抽象
get_keys({'a': 50},50)
['a']
位置参数是不可以交换位置的
def get_keys(dict_varibal, value):
return [k for k, v in dict_varibal.items() if v == value]
-
get_keys 函数名
-
（） 中为参数； dict_varibal： 形式上的参数，调用的时候传递的值才是实际的参数
-
return 是返回值
1、位置参数，不可以交换位置
2、关键字参数，可以不按照顺序去写
get_keys(dict_varibal={'a': 50}, value = 50)
['a']
get_keys(value = 50,dict_varibal={'a': 50})
['a']
问题：函数通过参数获取我们传递的值，函数中改变了参数的值，那么我们传递进去的值会改变吗？
def test(varibal):
varibal = 100
return varibal
var = 1
test(var)
100
print(var)
1
def test(varibal):
varibal.append(100)
return varibal
var= []
test(var)
[100]
var
[100]
不建议对可变类型在函数内进行更改，建议用函数返回值进行重新赋值
def test(varibal):
temp = varibal.copy()
temp.append(100)
return temp
var = []
var = test(var)
var
[100]
参数的收集
def test(name, age, *args, **kwargs):
print(name, age, *args, **kwargs) # 第一个*，收集参数，不写*则输出元组
test('wong', 13)
wong 13
test('wong', 13,23,'kihh',[23,45])
wong 13 23 kihh [23, 45]
dict_varibals = {
'weight':120,
'height':178
}
test('wong',13,dict_varibals)
wong 13 {'weight': 120, 'height': 178}
装饰器
a = 10
b = [12,12]
def test():
print('test')
c = test
可以把函数赋值给一个变量
c.__name__
'test'
def test(func):
return func
def func():
print('func run')
f = test(func)
f.__name__
f()
func run
函数可以当作函数的返回值进行返回
random.random() # 返回一个从0到1的浮点值
0.0943859175467403
def test():
return random.random()
# 函数返回的浮点值保留三个有效数字
def test():
return round(random.random(), 3)
test()
0.645
python另一个语法糖，装饰器
# 返回一个从0到1的浮点值
@decorator
def test():
return random.random()
@decorator
def test_two():
return random.random()*10
def decorator(func):
def wrapper(*args, **kwargs):
# do something
return round(func(*args, **kwargs), 2)
return wrapper
# f = decorator(test) 完全等价于装饰器@的写法
test()
0.07
test_two()
8.05
类
class Person:
def __init__(self, name, age):
self._name = name
self._age = age
def get_name(self):
return self._name
初始化函数中，self 后面的是实例化对象的属性，加下划线的意思是，代表这个属性是私有的，不应该访问
s = 'hello world'
s.center(12)
'hello world '
p = Person('wong', 12)
p.get_name()
'wong'
p_2 = Person('li', 11)
p_2.get_name()
'li'
pass 代表着什么都不做，只是占个位而已
class Student(Person): # 此处Student继承了Person的规则
pass
s = Student('liu', 24)
s.get_name()
'liu'
class Student(Person):
def set_score(self, score):
self._score = score
def get_score(self):
return self._score
s = Student('liu', 24)
s.get_name()
'liu'
s.set_score(100)
s.get_score()
100
class Person:
def __init__(self, name, age):
self._name = name
self._age = age
@property # 装饰器
def name(self):
return self._name
p = Person('liu', 34)
p.name
'liu'