今天学习的内容主要包括列表内置方法，元组类型，列表类型，字典类型，if选择，while循环，文件处理，函数基本概念等。

文件处理和函数后期会进行补充

一、列表:

   定义：在[]内，可以存放多个任意类型的值，并用逗号隔开，一般用于存放学生的爱好，课堂的周期等

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

   stu = ['hahaha','wawawa','lalala','aaaaaa']

   print(stu[1])#wawawa

   stu_info = ['xiaomabaoli',18,'male',['hahaha','lalala']]

 

   优先掌握的操作：

1、按索引取值（正向取+反向取）：只能取

print(stu_info[-2])#male

2、切片（顾头不顾尾，步长）

print(stu_info[0:4:2])#['xiaomabaoli', 'male']

3、长度len

print(len.(stu_info))#4

4、成员运算in和not in

print('lalala' in stu_info)#True

print('lalala' not in  stu_info)#False

5、追加append

stu_info = ['xiaomabaoli',18,'male',['hahaha','lalala']]

#在stu_info列表末尾追加一个数

stu_info.append('andwahaha')

print(stu_info)

6、删除

#删除索引为2的值

del stu_info[2]

print(stu_info)

7、循环

for student in student_info:

print(student)

 

需要掌握的：

stu_info = ['xiaomabaoli',18,'male',['hahaha','lalala']，18]

1、index 获取列表中某个值的索引

print(stu_info.index(18))#1

2、count获取列表中某个值的数量

print(stu_info.count(18))#2

3、pop取值，默认取列表中最后一个值，类似删除

若pop（）括号中写了索引，则取索引对应的值

stu_info.pop()

print(stu_info)

#取出列表中索引为2的值，并赋值给sex变量名

sex = stu_info.pop(2)

print(sex)

print(stu_info)

4、remove移除，把列表中某个值的第一个值移除

stu_info.remove(18)

print(stu_info)#['xiaomabaoli', 'male', ['hahaha', 'lalala']]

name=stu_info.remove('xiaomabaoli')

print(name)#None

print(stu_info)#['male', ['hahaha', 'lalala']]

5、insert插入值

stu_info = ['xiaomabaoli',18,'male',['hahaha','lalala']，18]

#在stu_info中，索引为3的位置插入emmmm

stu_info.insert(3,'emmmmm')

print(stu_info)

6、entend合并

student_info1 = ['hahaha', 18, 'male', ['wwww', 'aaaa'], 18]

student_info2 = ['lalala', 21, 'female', ['emmm', 'mmma']]

# 把student_info2所有的值插入student_info1内

student_info1.extend(student_info2)

print(student_info1)

二、元组：

    定义：

        在（）内，可以存放多个任意类型的值，并以逗号隔开

    注意

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

    优点：

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

        # 定义

        tuple1 = (1, 2, 3, '无', '开')

        print(tuple1)#(1, 2, 3, '无', '开')

优先掌握：

1、按索引取值（正向取+反向取）：只能取

        print(tuple1[2])#3

2、切片（顾头不顾尾，步长）

#从0开始切片到5-1，步长为3

print(tuple1[0:5:3])#(1,'无')

3、长度len

print(len(tuple1))#5

4、成员运算in和not in

print(1 in tuple1)

print(1 not in tuple1)

5、循环

for stu in stu_info:

#print(stu)

#print默认参数是\n

print(stu,end=' ')

三、字典类型

    作用：

           在｛｝内，以逗号隔开可存放多个值，以key-value存取，取值速度快

    定义：

            key必须是不可变类型，value可以是任意类型

 

    eg：dict1 = {'age':18,'name':'xiaoma'}

    print(dict1)

    print(type(dict1))# <class 'dict'>

    取值，字典名=[]，括号内写值对应的key

    print(dict1['age'])

    优先掌握：

    1、按key存取值:可存可取

    存一个level：9的值到dict1字典中

    dict['level']=9

    print(dict1)#{'age': 18, 'name': 'xiaoma', 'level': 9}

    print(dict1['name'])#xiaoma

    2、长度len

print(len(dict1))#3

    3、成员运算in 和 not in

print('name' in dict1)  # True

print('xiaoma' in dict1)  # False

print('xiaoma' not in dict1)  # True

    4、删除

    del dict1['level']

    print(dict1)#{'age': 18, 'name': 'xiaoma'}

    5、键key(),值value(),键值对items()

    得到字典中所有key

    print(dict1.keys())

    得到字典中所有值value

    print(dict1.values())

    得到字典中所有值items

    print(dict1.items())

    6、循环

    循环遍历字典中所有的key

    for key in dict1:

    print(key)

    print(dict1[key])

 

 get内容

    dict1 = {'age':18,'name':'xiaoma'}

    #print(dict1.get('age'))

 

# []取值

print(dict1['sex'])  # KeyError: 'sex'

 

# get取值

print(dict1.get('sex'))  # None

# 若找不到sex，为其设置一个默认值

print(dict1.get('sex', 'male'))

四、if和while

不可变类型:

    变量的值修改后，内存地址一定不一样。

    数字类型

        int

        float

    字符串类型

         str     

     元组类型

         tuple         

 可变类型:

     列表类型

         list

     字典类型

         dict

if 判断：

 语法：

    if 判断条件：

        #若条件成立，则执行此处代码

        逻辑代码

        elif判断条件

        #若条件成立，则执行此处代码

          逻辑代码

           else

        #若以上条件都不成立，则执行此处代码

           逻辑代码

Eg判断两数大小

    x=1

    y=2

    z=3

if(x>y)

    print(x)

 

elif(z>y)

    print(z)

 

else:

    print(y)

 

while循环

 语法：

   while 条件判断：

        #成立执行此处

        逻辑代码

    break #跳出本层循环

    continue#结束本次循环，进入下一次循环

    str1= 'xiaomabaoli'

#    while循环

while True:

    name = input('输入猜测的字符：').strip()

    if name == 'xioamabaoli'：

         print('successful')

         break

    print('重新输入')

 

# 限制循环次数

str1 = 'ma'

# 初始值

num = 0

while num < 3:

    name = input('输入猜测的字符：').strip()

    if name == 'ma':

        print('successful')

        break

    print('重新输入')

    num += 1

五、文件处理：

    open()

    写文件

        wt：写文本

    读文件

        rt：读文本

    追加写文件

        at：追加文本

#必须指定字符编码，以什么方式写就要以什么方式打开 如：utf-8

 

执行python文件的过程

        1.先启动python解释器，加载到内存中

        2.把写好的python文件加载到解释器中

        3.检测python语法，执行代码

        SyntaxError:语法错误

 

        打开文件会产生两种资源：

        1、python程序

        2、操作系统打开文件

 

写文本文件：

参数一：文件的绝对路径

参数二：mode操作文件的模式

参数三：encoding指定的字符编码

    f=open('file.txt',mode='wt',encoding='utf-8')

    f.write('hahaha')

    fclose()#关闭操作系统文件资源

    #读文本

    f = open('file.txt', 'r', encoding='utf-8')

    print(f.read())

    f.close()

#追加写文本文件

a = open（'file.txt','a',encoding='utf-8'）

a.write('hahaha')

a.close()

 

#文件处理之上下文管理：

with open() as f '句柄'

#写：

with open('file1.txt', 'w', encoding='utf-8') as f:

 f.write('lalala')

# 读

with open('file1.txt', 'r', encoding='utf-8') as f:

    res = f.read()

    print(res)

#追加

with open('file1.txt', 'a', encoding='utf-8') as f:

    f.write('wawawa')

# f.close()

对图片、音频、视频读写

rb模式，读取二进制，不需要指定字符编码

#读取相片 .jpg

with open('ama.jpg','rb') as f:

    res= f.read()

    print(res)

 

jpg = res

#把.jpg的二进制流写入ama_copy.jpg文件中

with open('ama_copy.jpg','wb')as f_w:

    f_w.write(jpg)

 

# 通过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)

 

六、函数

函数指的是一把工具

使用函数的好处：

    1、解决代码冗余问题

    2、使代码的结构更清晰

    3、易管理

 函数的使用必须遵循：先定义，后调用

 

    函数定义语法：

        def 函数名(参数1，参数2...):

        '''注释：声明函数'''

         逻辑代码

         return 返回值

 

        def：define 定义

        函数名 ：必须看其名知其意

        （）：接受外部传入的参数

        注释：用来声明函数的作用

        return :返回给调用者的值

 

定义函数的三种形式:

    1.无参函数：不需要接收外部传入的参数。

    2.有参函数：需要接收外部传入的参数。   

    3.空函数：pass

 

函数调用：

    函数名 + () 调用

#1、无参函数

def login():

    user = input("输入用户名:").strip()

    pwa = input("输入密码:").strip()

 

    if user == 'ma' and pwa == '123':

        print('ok')

    else:

        print('not ok')

 

# 函数的内存地址

print(login)

# 函数调用

login())

#2、有参函数

username,password 用来接收外部传入的值

def login(username, password):

    user = input("输入用户名:").strip()

    pwa = input("输入密码:").strip()

 

    if user == username and pwa == password:

        print('ok')

    else:

        print('not ok')

 

 

print(login)

 函数调用

若函数在定义时需要接收参数，调用者必须为其传参

 

#3、空函数

ATM：#比如由如下功能，现设计一些功能

    1.登录

    2.注册

    3.提现

    4.取款

    5.转账

    6.还款

#登录功能

def login()

    #表示什么都不做

    pass

#注册功能

def register()

    #表示什么都不做

    pass

#还款功能

def repay()

    #表示什么都不做

    pass

 

函数的参数：

在定义阶段：x,y称为形参。

def func(x,y):#x,y

    print(x,y)

#在调用阶段：10，100称之为实参

func(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)

不能少传

func(y=111)#报错

不能多传

func(y=111,x=222,z='333')#报错

 

默认参数：

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

 

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

    print(x,y)

#不传参,则使用默认参数

    foo()

#传参,使用传入的参数

    foo(200,300)

 

函数的嵌套定义:

    在函数内部定义函数

函数对象

函数的内存地址称之为函数对象。

函数的名称空间

    内置：

        python解析器自带的都称为‘内置名称空间’

    全局：

        所有顶着头写的变量、函数...都称为‘全名称空间’

    局部：

        在函数内部定义的，都称为‘局部名称空间’

    名称空间加载顺序：

        内置--->全局--->局部

    名称空间查找顺序：

        内置<---全局<---局部

#函数的嵌套定义

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])

    dict1[choice]()

if choice == '2':

    print(dic1[choice])

    dict1[choice]()

 

#名称空间

x=10

def func1():

    x=20

    print('from func1...')

    print(x)

    def func2():

        print('from func2...')

print(func1)#20

可以选择用globe定义全部变量