第六章 字典
- 在python中 ，字典是一系列键值对，每个键都与一个值关联，可以使用键来访问与之相关联的值；
- 与之关联的值可是数字、列表甚至字典；
- 事实上，可将任何Python对象用作字典中的值；键和值之间用冒号分隔；
- 字典用放在花括号{}中的一系列键对表示。
- 访问字典中的值
alien_0={'color':'green',"points":5}
print(alien_0['color'])#字典取值，用[]里面加对应的键
#运行结果：
green
- 字典是一种动态结构，可随时添加键值对，依次指定字典名、用方括号括起来的键和相关联的值
alien_0={'color':'green',"points":5}
alien_0['x_pos']=0
alien_0['y_pos']=25
print(alien_0)
#运行结果：
{'color': 'green', 'points': 5, 'x_pos': 0, 'y_pos': 25}
- 空字典
aline_0={}
- 修改字典中的值，依次指定字典名、用方括号括起来的键以及与该键相关的新值
alien_0={'color':'green',"points":5}
alien_0['color']='red'
print(alien_0)
#运行结果：
{'color': 'red', 'points': 5}
- 删除键值对，用del语句将相应的键值对彻底删除
alien_0={'color':'green',"points":5}
del alien_0['points']
print(alien_0)
#运行结果：
{'color': 'green'}
- 遍历字典，可使用for循环来遍历字典，先声明两个变量，用于存储键值 对中的键和值，for语就只有的第二部分包含字典和方法items()，返回一个键值对列表，接下来，for循环依次将每个键值对存储到指定的两个变量中。
alien_0={'color':'green',"sex":'F'}
for k,v in alien_0.items():
print("\nKey:"+k)
print("\nValue:"+v)
#运行结果：
Key:color
Value:green
Key:sex
Value:F
- 遍历所有键，方法keys()返回键列表。
alien_0={'color':'green',"sex":'F'}
for key in alien_0.keys():
print(key)
#运行结果：
color
sex
- 遍历所有值，方法values()返回键列表，可使用set()删除重复的值。
alien_0={'color':'green',"sex":'F'}
for value in alien_0.values():
print(value)
#运行结果：
green
F
- 嵌套
a. 字典列表
alien_0={'color':'green',"sex":'M'}
alien_1={'color':'red',"sex":'F'}
alien_2={'color':'yellow',"sex":'M'}
aliens=[alien_0,alien_1,alien_2]
print(aliens)
#运行结果：
[{'color': 'green', 'sex': 'M'}, {'color': 'red', 'sex': 'F'}, {'color': 'yellow', 'sex': 'M'}]
b. 在字典中存储列表
favorite_languages={'jimmy':['delphi','javascript','python'],
'jenny':['python'],
'jack':['python'],
}
for name,languages in favorite_languages.items():
print('\n'+name.title() + "'s favorite languages are:")
for language in languages:
print('\t' + language.title())
#运行结果：
Jimmy's favorite languages are:
Delphi
Javascript
Python
Jenny's favorite languages are:
Python
Jack's favorite languages are:
Python
c. 在字典中存储字典
runner={
'DK':{
'dept':'IT',
'level':'A'
},
'John':{
'dept':'PM',
'level':'A'
},
}
for name,info in runner.items():
print('\nname:' + name)
dept=info['dept']
level=info['level']
print('\tFrom dept:' + dept)
print('\trun level:' + level)
#运行结果：
name:DK
From dept:IT
run level:A
name:John
From dept:PM
run level:A
第七章 用户输入和while循环
一. 函数input()的工作原理
函数input()让程序暂停运行，等待用户输入一些文本，获取用户输入后，Python将其存储在一个变量中，以便使用。
message = input('tell me something:')
print(message)
二. 取余运算符
%取余运算，返两数个相除的余数。
print(4 % 3)
#运行结果：
1
三. while 循环
- for循环用于针对集合中的每个元素都执行一个代码块，而while循环不断地运行，直到指定的条件不满足为止。
#例1
num=1
while num<3:
print(num)
num+=1
#运行结果：
1
2
#例2
prompt='\ntell me somethine, and I will repeat it back to you:'
promtp+='\nEnter "q" to end the program.'
msg=''
while msg != 'q':
msg=input(prompt)
print(msg)
- 使用break退出循环
#例1
num=1
while num<5:
if num % 2 == 0:
break
print(num)
num+=1
#运行结果：
1
- 循环使用continue
num=0
while num<5:
num+=1
if num % 2 == 0:
print(num)
continue
#运行结果：
2
4
- 使用while循环处理列表和字典
a. 列表之间移动元素
b. 删除包含特定值的所有列表元素
c. 使用用户输入来填充字典
第八章 函数
一. 定义函数
- 使用关键字def来告诉Python定义一个函数，指出函数名，在括号内指出函数为完成其任务需要什么样的信息，也可以不指定，即便为空，括号必不可少，最后以冒号结尾。
#例2
def greet_user():
print('Hello')
greet_user()
#运行结果：
Hello
#例2
def greet_user(name): #name：形参
print('Hello '+name.title())
greet_user('Kobe') #Kobe：实参
#运行结果：
Hello Kobe
- 传递实参
鉴于函数定义中可能包含多个形参，因此函数调用中也可能包含多个实参，向函数传递实参的方式：位置实参，要求实参的顺序与形参的顺序相同；使用关键字实参，其中每个实参都由变量名和值组成；还可使用列表和字典。
a. 位置实参，调用时，必须将函数中的每个实参都关联到函数定义中的一个形参，因此最简单的关联方式是基于实参顺序
def user_info(name,sex):
print("\nI'm " + name.title())
print("My sex is " + sex)
user_info('Kobe','Man')
#运行结果：
I'm Kobe
My sex is Man
b. 关键字实参，是传递给函数的名称-值对，直接在实参中将名称和值关联起来，所以向函数传递实参时不会混淆，无需考虑函数调用实参的顺序，还清楚地指出函数调用各个值的用途。使用关键字实参时，必须准确地指定函数定义中的形参名
def user_info(name,sex):
print("\nI'm " + name.title())
print("My sex is " + sex)
user_info('Kobe','Man')
user_info(sex='Man',name='Kobe')
#运行结果：
I'm Kobe
My sex is:Man
I'm Kobe
My sex is Man
c. 默认值，编写函数时，可给每个形参指默认值，如果调用中给形参提供了实参，将使用指定的实参值，否则，将使用默认值。形参指定默认值后，调用时可省略相应的实参。
def user_info(name,sex='Femal'):
print("\nI'm " + name.title())
print("My sex is " + sex)
user_info('Jesse')
user_info(sex='Man',name='Kobe')
#运行结果：
I'm Jesse
My sex is:Femal
I'm Kobe
My sex is Man
- 返回值，在函数中使用return语句将值返回到调用函数的代码行，返回值 让你能够将程序的大部分繁重的工作移到函数中去完成，从而简化主程序。函数可以返回任何类型的值
a. 返回单个值
def get_full_name(first_name,middle_name,last_name):
full_name=first_name + ' ' + middle_name + ' ' + last_name
return full_name.title()
full_name=get_full_name('john','lee','hooker'):
print(full_name)
#运行结果：
John lee hooker
b. 返回字典
def build_user(first_name,middle_name,last_name):
user={'first':first_name,'middle':middle_name , 'last' : last_name}
return user
user=build_user('john','lee','hooker')
print(user)
#运行结果：
{'first': 'john', 'middle': 'lee', 'last': 'hooker'}
- 传递列表
传递原列表，函数可以修改和删除列表；要想保持原来列表不变，调用时可传递列表副本（例2）
#例1
def greet_user(names):
for name in names:
print('Hello '+name.title())
greet_user(['Kobe','Curry'])
#运行结果：
Hello Kobe
Hello Curry
#例2
def greet_user(un_greet_users,greeted_users):
while un_greet_users:
name=un_greet_users.pop()
greeted_users.append(name)
un_greet_users=['Kobe','Curry']
greeted_users=[]
greet_user(un_greet_users,greeted_users)
print('First call greet_user Result:')
print(un_greet_users)
print(greeted_users)
un_greet_users=['Kobe','Curry']
greeted_users=[]
greet_user(un_greet_users[:],greeted_users)
print('Second call greet_user Result:')
print(un_greet_users)
print(greeted_users)
#运行结果：
First call greet_user Result:
[]
['Curry', 'Kobe']
Second call greet_user Result:
['Kobe', 'Curry']
['Curry', 'Kobe']
- 传递任意数量的实参
def make_pizza(*toppings):
print(toppings)
make_pizza('apple')
make_pizza('pear','rice','fish')
#运行结果：
('apple',)
('pear', 'rice', 'fish')
#例2
def make_pizza(*toppings):
print("\nMaking a pizza with the following toppings:")
for topping in toppins:
print('-' + topping)
make_pizza('apple')
make_pizza('pear','rice','fish')
#运行结果：
Making a pizza with the following toppings:
-apple
Making a pizza with the following toppings:
-pear
-rice
-fish
形参*toppings中的*号让Python创建一个名为toppings的空元组，并将收到的所有值都封装到这个元组中，即使用只有一个也是如此
- 使用任意数量的关键字实参
def build_user(name,**user_info):
profile={}
profile['name']=name
for key,value in user_info.items():
profile[key]=value
return profile
user_info=build_user('Kobe',team='Lakers',age=40)
print(user_info)
#运行结果：
{'name': 'Kobe', 'team': 'Lakers', 'age': 40}
形参**user_info中的两个星号让Python创建一个名为user_info的空字典，并将收到的所有名称-值对都封装到这个字典中。
7.将函数存储在模块中
函数的优点之一是，使用它们可将代码块与主程序分离，通过函数措定描述性名称，可让主程序容易理解；
还可以在将函数存储在被称为独立模块的独立文件中，再将模块导入到主程序中，import语句允许在当前运行的程序文件中使用模块中的代码。
a. 导入整个模块： import 模块名，模块名是扩展名为.py的文件
b. 导入特定函数：from 模块名 import 函数名
c. 使用as给函数指定别名：from 模块名 import 函数名 as 别名
d. 使用as给模块指定别名：import 模块名 as 别名
e. 导入模块中所有函数：from 模块名 import *,可以通过函数名称直接调用函数，无需使用句点表示法
- 函数编写指南
给函数指定描述性名称，且只在其中使用小写字母和下划线
每个函数都应包含简要阐述其功能的注释，该注释应紧跟在函数定义后面，并采用文档字符串格式
