day two Python学习之列表、元组、字典、流程控制、文件处理和函数

dict({'name': 'panghu', 'age': 19})
dict1 = {'name': 'panghu', 'age': 19}
# 1
print(dict1['name'])#panghu
dict1['level'] = 9  # 存一个'level': 9到字典中
print(dict1)#{'name': 'panghu', 'age': 19, 'level': 9}
#2 3
print(len(dict))
print('name' in dict1)#True
print(19 in dict1)#value进行成员运算只能得到False
#4del
del dict1['level']
print(dict1)#{'name': 'panghu', 'age': 19}
#5 键keys()，值values()，键值对items()
#得到字典中的所有key
print(dict1.keys())#dict_keys(['name', 'age'])
#得到字典中的所有values
print(dict1.values())#dict_values(['panghu', 19])
#得到字典中的所有items
print(dict1.items())#dict_items([('name', 'panghu'), ('age', 19)])
#6循环
for key in dict1:
    print(key)#只能得到name和age，就是key
    print(dict1[key])#得到panghu和19，就是value
#get
print(dict1.get('age'))#用get找不到会提示不存在输出None(better)
print(dict1['age'])#用中括号找不到直接报错
#如果找不到sex，为其设置一个默认值
print(dict1.get('sex','male'))#默认值并不会写入到dict1中，只是得到一个结果
print(dict1.get('name','male'))#如果可以找到name，直接无视默认值

x = 5
y = 10
if x > y:
    print(x)
elif x == y:
    print('same')
else:
    print(y)

while True:#使用True实现无限循环，直到break
    name = input('请输入猜测的字符：').strip()
    if name == 'tank':
        print('tank success!')
        break
    print('请重新输入！')

num = 0
while num<3:#使用num来实现有限次的循环
        name = input('请输入猜测的字符：').strip()
        if name == 'tank':
            print('tank success!')
            break
        print('请重新输入！')
        num+=1

tag=True 

　　while tag:

　　　　......

　　　　while tag:

　　　　　　........

　　　　　　while tag:

　　　　　　　　tag=False

#与其它语言else 一般只与if 搭配不同，在Python 中还有个while ...else 语句，while 后面的else 作用是指，当while 循环正常执行完，中间没有被break 中止的话，就会执行else后面的语句
count = 0
while count <= 5 :
    count += 1
    print("Loop",count)

else:
    print("循环正常执行完啦")
print("-----out of while loop ------")
输出
Loop 1
Loop 2
Loop 3
Loop 4
Loop 5
Loop 6
循环正常执行完啦
-----out of while loop ------

#如果执行过程中被break啦，就不会执行else的语句啦
count = 0
while count <= 5 :
    count += 1
    if count == 3:break
    print("Loop",count)

else:
    print("循环正常执行完啦")
print("-----out of while loop ------")
输出

Loop 1
Loop 2
-----out of while loop ------

for i in range(1,10):
    for j in range(1,i+1):
        print('%s*%s=%s' %(i,j,i*j),end=' ')
    print()

#分析
'''

             #max_level=5
    *        #current_level=1，空格数=4，*号数=1
   ***       #current_level=2,空格数=3,*号数=3
  *****      #current_level=3,空格数=2,*号数=5
 *******     #current_level=4,空格数=1,*号数=7
*********    #current_level=5,空格数=0,*号数=9

#数学表达式
空格数=max_level-current_level
*号数=2*current_level-1

'''

#实现
max_level=5
for current_level in range(1,max_level+1):
    for i in range(max_level-current_level):
        print(' ',end='') #在一行中连续打印多个空格
    for j in range(2*current_level-1):
        print('*',end='') #在一行中连续打印多个空格
    print()

打印金字塔

# 写文本文件
f = open('file.txt', mode='wt', encoding='utf-8')  # 操作系统打开文件
f.write('tank')
f.close()  # 关闭操作系统文件资源
# 读文本文件
f = open('file.txt', 'r', encoding='utf-8')  # r就是rt
print(f.read())
f.close()
# 追加写文本文件
a = open('file.txt', 'a', encoding='utf-8')
a.write('\n 6666')
a.close()

文件处理之上下文管理：#with可以管理open打开的文件，
#会在with执行完毕后自动调用close()关闭文件,具体就是使用with open()语句
with open('file.txt', 'w', encoding='utf-8') as f:  # with open()as f:句柄
    f.write("haohen")
with open('file.txt', 'r', encoding='utf-8') as f:  # with open()as f:句柄
    res = f.read()
    print(res)
with open('file.txt', 'a', encoding='utf-8') as f:  # with open()as f:句柄
    f.write("666")
#程序执行完后可在文本文档中写入haohen666

#读取图片
with open('cxk.jpg','rb') as f:
    res = f.read()
    print(res)
jpg=res
#把cxk.jpg的二进制流写入cxk_copy.jpg文件中
with open("cxk_copy.jpg",'wb') as f_w:
    f_w.write(jpg)
#通过这个程序，可以得到与cxk.jpg一模一样的cxk_copy.jpg

#with管理多个文件
#通过with来管理open打开的两个文件句柄f_r,f_w
with open('cxk.jpg','rb') as f_r,open("cxk_copy.jpg",'wb') as f_w:
    res = f_r.read()
    f_w.write(res)
#程序最终结果是与上面的那个程序运行结果一致，而且减少了代码行数

'''
  　　- 事先准备工具的过程----> 函数的定义

  　　- 把工具拿过来使用----> 函数的调用

  　　- 所以函数的使用必须遵循: ----> 先定义，后调用
'''

#1、无参：应用场景仅仅只是执行一些操作，比如与用户交互，打印
#2、有参：需要根据外部传进来的参数，才能执行相应的逻辑，比如统计长度，求最大值最小值
#3、空函数：设计代码结构

#形参即变量名，实参即变量值，函数调用时，将值绑定到变量名上，函数调用结束，解除绑定

def 函数名(参数1,参数2,参数3,...):
    #文档描述
    函数体代码1
    函数体代码2
    ...
    return 返回的值

1.def（即defind，翻译过来是定义！）: 是声明函数的关键字。
2.函数名: 用来调用函数的。函数的命名应该尽量反应出其代表的功能。也就是看其名知其意！
3.(): 括号内是函数的参数,函数的参数可以有一个或者多个。
#4.注释/: 推荐写上，增强函数的可读性！
5.函数体: 具体的逻辑代码。
6.return: 函数返回的值。

def name():
    print('666')
print(name)#函数的内存地址
name()#函数调用

#参数的参数
def name1(a,b):#在定义时a和b称之为形参
    c = input().strip()
    d = input().strip()
    if c==a and d==b:
        print('nice')
    else:
        print('bad')
name1('1','2')#在调用阶段：1，2称为实参

#空函数的简单举例
def aa():
    pass

'''
位置参数：
    位置形参
    位置实参
    必须按照位置一一传参
'''
#在定义阶段：位置形参
def func(x,y):
    print(x,y)
func(10,100)#在调用阶段：10，100称位置实参

'''
关键字参数：
    关键字实参
    按照关键字传参
'''
def func(x,y):#位置形参x，y
    print(x,y)
func(x=10,y=100)#在调用阶段：x=10，y=100称之为关键字参数
#func(x=10) func(x=10,y=100,z=999)不能少传和多传，会报错

'''
默认参数：
    在定义阶段，为参数设置默认值
'''
def foo(x=10,y=20):
    print(x,y)
foo()#不传参，则使用默认参数
foo(200,300)#传参，使用传入的参数

函数的嵌套定义：在函数内部定义函数。
函数对象：函数的内存地址称之为函数对象
函数的名称空间：
    内置：python解析器自带的都称之为“内置名称空间”。
    全局：所有顶着头写的变量、函数。。。都称之为“全名称空间”。
    局部：在函数内部定义的，都称之为“局部名称空间”
    名称空间加载顺序：内置--》全局--》局部
    名称空间查找顺序：局部--》全局--》内置

#函数的嵌套的定义
def a():
    print('1')
    def b():
        print('2')
#函数对象
print(a)
def f1():
    pass
def f2():
    pass
dic1={'1':f1,'2':f2}
choice = input('请选择功能编号：')
if choice== '1':
    print(dic1[choice])
    dic1[choice]()
elif choice== '2':
    print(dic1[choice])
    dic1[choice]()

x=10
#名称空间
#函数的嵌套定义
def func1():
    #x=20
    print('from func1...')
    print(x)
    #x=30,代码自上而下执行，会报错
    def func2():
        print('from func2...')
func1()

#1、位置参数：按照从左到右的顺序定义的参数
        位置形参：必选参数
        位置实参：按照位置给形参传值

#2、关键字参数：按照key=value的形式定义的实参
        无需按照位置为形参传值
        注意的问题：
                1. 关键字实参必须在位置实参右面
                2. 对同一个形参不能重复传值

#3、默认参数：形参在定义时就已经为其赋值
        可以传值也可以不传值，经常需要变得参数定义成位置形参，变化较小的参数定义成默认参数（形参）
        注意的问题：
                1. 只在定义时赋值一次
                2. 默认参数的定义应该在位置形参右面
                3. 默认参数通常应该定义成不可变类型


#4、可变长参数：
        可变长指的是实参值的个数不固定
        而实参有按位置和按关键字两种形式定义，针对这两种形式的可变长，形参对应有两种解决方案来完整地存放它们，分别是*args，**kwargs

        ===========*args===========
        def foo(x,y,*args):
            print(x,y)
            print(args)
        foo(1,2,3,4,5)

        def foo(x,y,*args):
            print(x,y)
            print(args)
        foo(1,2,*[3,4,5])


        def foo(x,y,z):
            print(x,y,z)
        foo(*[1,2,3])

        ===========**kwargs===========
        def foo(x,y,**kwargs):
            print(x,y)
            print(kwargs)
        foo(1,y=2,a=1,b=2,c=3)

        def foo(x,y,**kwargs):
            print(x,y)
            print(kwargs)
        foo(1,y=2,**{'a':1,'b':2,'c':3})


        def foo(x,y,z):
            print(x,y,z)
        foo(**{'z':1,'x':2,'y':3})

        ===========*args+**kwargs===========

        def foo(x,y):
            print(x,y)

        def wrapper(*args,**kwargs):
            print('====>')
            foo(*args,**kwargs)

#5、命名关键字参数：*后定义的参数，必须被传值（有默认值的除外），且必须按照关键字实参的形式传递
可以保证，传入的参数中一定包含某些关键字
        def foo(x,y,*args,a=1,b,**kwargs):
            print(x,y)
            print(args)
            print(a)
            print(b)
            print(kwargs)

        foo(1,2,3,4,5,b=3,c=4,d=5)
        结果：
            2
            (3, 4, 5)
            3
            {'c': 4, 'd': 5}

此乃重点知识！！！