python day 3

1 f = open(‘1.txt‘,‘r‘,encoding=‘utf-8‘)
2     
3 with open(‘1.txt‘,‘r‘,encoding=‘utf-8‘) as f:
4     print (f.read())

1 注意两点：
2   1.打开一个文件定义两部分，一个是python级别的文件句柄，另一个是操作系统打开的文件（默认）
3      打开文件的编码是以操作系统的编码为准，除非open()指定编码
4   2.当文件操作完毕后，应该回收两部分资源
5      del f ：回收应用程序资源（python解释器字典的垃圾回收机制已经替我们做了）
6      f.close()回收操作系统

 1   r :默认的打开模式，只读，文件不存在则报错
 2   f.read() 读取文件的所有内容
 3   f.readline() 一次读一行
 4    print(readline(),end=‘‘)不读取换行符
 5   f.readlines() 读所有，结果放入列表
 6   
 7   w :只写模式，如果文件存在则清空，如果文件不存在则创建
 8   f= open(‘1.txt‘,‘w‘,encoding=‘utf-8‘)
 9   f.write(‘1111\n‘)
10   f.writelines()写入多行
11   
12   a ：追加写模式，如果文件不存在则新建，存在则把光标移动到问及那末尾
13   f= open(‘1.txt‘,‘a‘,encoding=‘utf-8‘)
14   f.write(‘1111\n‘)
15   f.writelines()写入多行
　　　rb : 以bytes的形式去操作文件内容，不能指定编码
  f = open(‘1.jpg‘,‘rb‘)

1  1.组织结构混乱，可读性差
2  2.代码冗余
3  3.无法统一管理，维护难度大
4  函数的使用必须遵循：先定义，后调用

1 内置函数：python 解释器自带的函数，python解释器启动就会定义好
2  自定义函数：
3   1.函数的使用必须遵循：先定义，后调用
4   2.函数的定义，就相当于在定义一个变量，如果没有定义
5  语法：
6   def 函数名（参数1，参数2，.....）： 
7    ‘‘‘注释‘‘‘
8    函数体
9    return  返回值

定义函数阶段：
函数在定义阶段，只检测语法，不执行代码
    1.无参：函数体不需要外部的值        
    2.有参：函数体的代码，需要外部的值
        def my_max(x,y):
            if x > y:
                return x
            else:
                return y
        res = my_max(10,20)
            
    3.空函数：
        def foo():
            pass

 1 调用函数阶段：
 2  1.函数名（）
 3  需要注意：通过名字找到函数的内存地址，然后加括号调用
 4  2.函数的返回值return
 5   在调用函数的过程中，一旦执行return，就会立刻终止函数，并且把return后的结果当做本次的返回值返回
 6   函数体内可以有多个
 7  注意第二点：
 8   返回的值，可是任意类型
 9  注意第三点：
10   没有return ，默认返回None
11   可以返回一个值（类型是值的类型）
12   可以用逗号分隔，返回多个值==元组的类型

1 def foo():
2    print (‘1111‘)
3    return 123
4 foo()
5   name = foo()
6   name = foo()*10 等于 name = 23 * 10

1.位置参数：
            位置形参：必须被传值得参数，多一个不行，少一个也不行
            位置实参：从左到右依次赋值给形参
        2.关键字参数：在函数调用阶段按照key=value的形式定义实参
                      可以不依赖位置而指名道姓的给形参传值
                      需要注意的问题（可以与位置实参混用：但是）
                      1.位置实参必需在关键字实参的前面
                      2.不能为一个形参重复传值
                      
            def foo(x,y):
                print (x,y)
            
            foo(y=1,x=2)
        3.默认参数：在函数的定义阶段，已经为形参赋值了，在定义阶段已经赋值，意味着在调用可以不传值
            def foo(x,y=10):
                print(x,y)    
            foo(1)
            注意的问题：
                1.默认参数的值，只在定义是赋值一次
                2.位置形参应该在默认参数的前面(def foo(x,y=2,c))这样都是错误的
                3.默认参数的值应该是不可变类型 
        4.可变长参数
            实参可变长度指的是：实参的个数是不固定的
            而实参的定义形式无非两种：1、位置实参 2、关键字实参
            针对这两种形式的实参个数不固定，相应的，形参也要有两种解决方案
            针对位置实参溢出的部分实参，*args
            def  func(x,y,*args): #args=(3,4,5,6,7)
                print (x,y,args)
                
            l = [1,2,3,4,5,6,7]
            func(*l)
            针对按照关键字定义的溢出的那部分实参，形参:**args
            def foo(x,y,**args): # args = {‘a‘:1,‘b‘:2}
                print(x,y,args)
            foo(1,2,3,**{‘a‘:1,‘b‘:2})
        5.命名关键字参数（了解）:形参中，在*后定义的参数称之为命名关键字参数
            他的特性是：传值时,必须按照关键字实参的形式传值
            def foo(x,y,*,a,b):
                
        位置参数，默认参数，*args ，命名关键字参数

 1     函数的嵌套调用
 2     def 
 3     函数的嵌套定义：在定义一个函数内部，又定义了一个函数
 4     def f1():
 5         def f2():
 6             def f3():
 7                 print (‘11111‘)
 8             f3()
 9         f2()        
10     f1()

 1     1.名称空间：存放名字与值绑定关系的空间
 2         全局名称空间
 3             存放的是：文件级别定义的名字与值的绑定关系
 4             生效：执行python文件时，以该文件级别定义的名字与值的绑定古纳西
 5             失效：文件执行完毕
 6         局部名称空间
 7             存放的是：函数内部定义的名字与值的绑定关系
 8             生效：调用函数时，临时生效
 9             失效：函数调用结束
10         内置名称空间
11             存放的是：内置的名字与值得绑定关系
12             生效：python  解释器启动
13             失效：python 关闭
14         加载顺序：
15             先内置，再全局，最后局部
16         查找名字的顺序：
17             先局部，再全局，最后内置
18     2.作用域：
19         全局作用域：包含内置名称空间的名字与全局名称空间的名字
20                     全局存活，全局有效
21         局部作用域：包含局部名称空间的名字
22                     临时存活，局部有效
23     作用域关系，在函数定义是，就已固定了，与调用无关
24     global   声明内部变量是全局变量
25         def f1():
26             global x
27             x = 1
28     nonlocal x