Pythone入门到实践-学习笔记-Day2

第六章 字典

1. 在python中 ，字典是一系列键值对，每个键都与一个值关联，可以使用键来访问与之相关联的值；
2. 与之关联的值可是数字、列表甚至字典；
3. 事实上，可将任何Python对象用作字典中的值；键和值之间用冒号分隔；
4. 字典用放在花括号{}中的一系列键对表示。
5. 访问字典中的值

alien_0={'color':'green',"points":5}
print(alien_0['color'])#字典取值，用[]里面加对应的键
#运行结果：
green

6. 字典是一种动态结构，可随时添加键值对，依次指定字典名、用方括号括起来的键和相关联的值

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}

7. 空字典

aline_0={}

8. 修改字典中的值，依次指定字典名、用方括号括起来的键以及与该键相关的新值

alien_0={'color':'green',"points":5}
alien_0['color']='red'
print(alien_0)
#运行结果：
{'color': 'red', 'points': 5}

9. 删除键值对，用del语句将相应的键值对彻底删除

alien_0={'color':'green',"points":5}
del alien_0['points']
print(alien_0)
#运行结果：
{'color': 'green'}

10. 遍历字典，可使用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

11. 遍历所有键，方法keys()返回键列表。

alien_0={'color':'green',"sex":'F'}
for key in alien_0.keys():
  print(key)
#运行结果：
color
sex

12. 遍历所有值，方法values()返回键列表，可使用set()删除重复的值。

alien_0={'color':'green',"sex":'F'}
for value in alien_0.values():
  print(value)
#运行结果：
green
F

13. 嵌套
    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 循环

1. 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)

2. 使用break退出循环

#例1
num=1
while num<5:
  if num % 2 == 0:
    break
  print(num)
  num+=1
#运行结果：
1

2. 循环使用continue

num=0
while num<5:
    num+=1
    if num % 2 == 0:
        print(num)
        continue  
#运行结果：
2
4

3. 使用while循环处理列表和字典
   a. 列表之间移动元素
   b. 删除包含特定值的所有列表元素
   c. 使用用户输入来填充字典

第八章 函数

一. 定义函数

1. 使用关键字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

2. 传递实参
   鉴于函数定义中可能包含多个形参，因此函数调用中也可能包含多个实参，向函数传递实参的方式：位置实参，要求实参的顺序与形参的顺序相同；使用关键字实参，其中每个实参都由变量名和值组成；还可使用列表和字典。
   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

3. 返回值，在函数中使用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'}

4. 传递列表
   传递原列表，函数可以修改和删除列表；要想保持原来列表不变，调用时可传递列表副本（例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']

5. 传递任意数量的实参

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的空元组，并将收到的所有值都封装到这个元组中，即使用只有一个也是如此

6. 使用任意数量的关键字实参

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 *,可以通过函数名称直接调用函数，无需使用句点表示法

8. 函数编写指南

给函数指定描述性名称，且只在其中使用小写字母和下划线
每个函数都应包含简要阐述其功能的注释，该注释应紧跟在函数定义后面，并采用文档字符串格式