python基础之---day2

列表:

           : 在[   ]内，可以存放多个任意类型的值；

             并以逗号隔开。 一般用于存放学生的爱好；课堂的周期等等...

例如：

        定义一个学生列表，可存放多个学生

    list(['钱垚', '李小龙', '张全蛋', '赵铁柱'])
    students = ['钱垚', '李小龙', '张全蛋', '赵铁柱']
    print(students[1])  # 李小龙
    student_info = ['杨波', 84, 'male', ['泡8', '喝9']] 
    print(student_info[3]) #取杨波同学的所有爱好
    print(student_info[3][1]) #取杨波同学的第二个爱好

优先掌握的操作：
1.按索引存取值（正向存取+方向存取）：即可存也可以取
print(student_info[-2]) #杨波
2.切片（顾头不顾尾，步长）
print(student_info[0:4:2])  #['杨波','male']
3.长度
print(len(student_info))  
4.成员运算in和not in
print('杨波'in student_info) #True
print('杨波'not in student_info) #False
5.追加
student_info=['杨波',84,'male',['泡8','喝9']]
student_inf0.append('安徽最牛的学院，合肥学院')
6.删除
#删除列表中索引为2的值
del student_info[2]
print(student_info)
7.插入值：
student_info=['尹浩卿',95,'female',['尬舞','喊麦'],95]
#在student_info中，索引为3的位置插入“合肥学院”
student_info.insert(3,'合肥学院')
print(student_info)
8.插入值：.extend合并列表
student_info1=['尹浩卿',95,'female',['尬舞1','喊麦2'],95]
student_info2=['娄逸夫',94,'female',['尬舞1','喊麦2']]
9.把student_info2所有的值插入student_info1内
student_info1.extend(student_info2)
print(student_info1)


元组：
       定义：在()内，可以存放多个任意类型的值，并以逗号隔开。

       注意：

          元组与列表不一样的是，只能在定义时初始化值，不能对其进行修改。

       优点:

           在内存中占用的资源比列表要小

列如：

tuple((1,2,3,'五','六'))
tuplel=(1,2,3,'五','六')
print(tuplel)#(1,2,3,'五','六')
优先掌握的操作：
1.按索引存取值（正向取+方向取）：只能取
print(tuplel[2]) #2
2.切片（顾头不顾尾，步长）
print(tuplel[0:5:3])  #(1,'五')
3.长度
print(len(tuplel))  #5
4.成员运算in和not in
print(1 in tuplel) #True
print(1 not in tuplel) #False
5.循环
for line in tuplel:
    #print(line)
    #print默认end参数是\n
    print(line,end='_')

if 判断:
    语法:
        if 判断条件:
            # 若条件成立，则执行此处代码
            逻辑代码

        elif 判断条件:
            # 若条件成立，则执行此处代码
            逻辑代码

        else:
            # 若以上判断都不成立，则执行此处代码
            逻辑代码

例如：
#判断两数大小
x=10
y=20
z=30
缩进快捷键，tab往右移动四个空格，shift+tab 往左移动四个空格
if x>y:
    print(x)
elif z>y:
    print(z)
else:
    print(y)


文件处理:
   open()
   写文件
      wt:写文本
   读文件
      rt:读文本
   追加写文件
      at:追加文本
注意：必须指定字符编码(字集码，是把字符集中的字符编码为指定集合中的某一对象，以便文本在计算机中存储和通过通信网络的传递)
 以什么方式写，就得以什么方式打开。

 执行python代码的过程：
   1.先启动Python解释器，加载到内存中。
   2.把写好的Python文件加载到解释器中。
   3.检测Python语法，执行代码。
   SyntaxError:语法错误！

打开文件会产生两种资源：
   1.python程序
   2.操作系统打开文件

例如：

 参数一：文件的绝对路径
 参数二：操作文件的模式
 参数三：encoding指定的字符编码
f = open('file.txt', mode='wt', encoding='utf-8')
f.write('tank')
f.close()  # 关闭操作系统文件资源

读文本文件  r==rt
f = open('file.txt', 'a', encoding='utf-8')
a.write('\n合肥学院')
a.close()

文件处理之上下文管理
with open()as f"句柄"

写
with open('file.txt', '', encoding='utf-8')as f:
    f.write('墨菲定律')

读
with open('file.txt', 'r', encoding='utf-8')as f:
    res = f.read()
print(res)

追加
with open('file.txt', 'a', encoding='utf-8')as f:
    f.write('围城')
f.close()

对图片、音频、视频读写
rb模式，读取二进制，不需要指定字符编码
with open('cxk.jpg', 'rb')as f:
    res = f.read()
    print(res)

jpg = res
 把cxk.jpg的二进制流写入cxk_copy.jpg文件中
with open('cxk_copy1.jpg', 'wb')as f_w:
    f_w.write(jpg)

with 管理多个文件
通过with来管理open打开的两个文件句柄f_r,f_w
with open('cxk.jpg', 'rb')as f_r, open('cxk_copy2.jpg', 'wb') as f_w:
    # 通过f_r句柄把图片的二进制流读取出来
    res = f_r.read()
    # 通过f_w句柄把图片的二进制流写入cxk_copy.jpg文件中
    f_w.write(res)


 def：
     defind 定义。
        函数名：必须看其名知其意。
       (  ):接受外部传来的参数。
       注释：用来声明函数的作用。
       Return:返回给调用者的值。

定义函数的三种形式：
  1.无参函数
    不需要接收外部传来的参数。
  2.有参函数
    需要接受外部传入的参数。
  3.空函数
    pass


1.无参函数
def login():
    user=input('请输入用户名').strip()
    pwd=input('请输入密码').strip()

    if user=='tank'and pwd=='123':
        print('login successful!')
    else:
        print('login error!')

函数的内存地址
print(login)

函数调用
login()

2.有参函数
username,password用来接收外部传入的值
def login(username,password):
    user=input('请输入用户名').strip()
    pwd=input('请输入密码').strip()

    if user==username and pwd==password:
        print('login successful!')
    else:
        print('login error!')

函数调用
若函数在定义时需要接收参数，调用者必须为其穿传参
login('tank','123')

3.空函数

ATM:
  1.登录
  2.注册
  3.提现
  4.取款
  5.转账
  6.还款


登录功能
def login():
    #代表什么都不做
    pass

还款功能
def repay():
    pass

参数的参数：
#在定义阶段：x，y称之为形参。
def func(x,y): #x,y
    print(x,y)

在调用阶段：10,100称之为实参。
 func(10,100) #10 100

位置参数：
  位置形参
  位置实参
  必须按照位置一一传参。

 在定义阶段：位置形参
 def func(x,y):#x,y
     print(x,y)

#在调用阶段：10,100称位置实参。
func(10,100)  #10 100

关键字参数：
   关键字实参
   按照关键字传参。

位置形参x,y
def func(x,y):
    print(x,y)
在调用阶段：x=10，y=100称之为关键字参数。
func(y=111,x=10) #10 111

不能少传
func(y=111) #报错TypeError

默认参数：
  在定义阶段，为参数设置默认值

def foo(x=10,y=20):
    print(x,y)

不传参，则使用默认参数
foo()
传参，使用传入的参数
foo(200,300)

函数的嵌套
      定义：在函数内部定义函数。
     函数对象
        函数的名称空间:
     全局：
         所有顶着头写的变量、函数...都称之为"全局名称空间"。
     局部：
        在函数内部定义的，都称之为“局部名称空间”。
        名称空间加载顺序： 
        内置--->全局--->局部
       名称空间查找顺序：
       局部--->全局--->内置

例如：
函数的嵌套定义
def func1():
    print('from func1...')
    def func2():
        print('from func2...')
函数对象
print(func1)
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)
def func2():
    print('from func2...')
func1()