day02 python基础

今日内容：

1、常用数据类型及内置方法

2、文件处理

3、函数

，，，

01、列表：

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

      一般用于存放学生的爱好，课堂的周期等等...

，，，

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

Students=[‘mx’，‘wq’，‘wzq’]

Print（student[1]）#mx

Student_info=[‘wzq’，21，‘f’,[‘摄影’‘吃’]]

#取wzq同学的所有爱好

Print(student_info[3])

#取wzq同学的第二个爱好

Print（student_info[3][1]）

#优先掌握的操作：

#1、按索引存取值（正向存取+反向存取）：即可存也可取

Print(student_info[-2])#

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

print(student_info[0,4,2])#

#3、长度

print（len(student_info)#

#4、成员运算in和not in

print(‘wzq’ in student_info) #True

print(‘wzq’ not in student_info) #False

#5、追加

Student_info=[‘万紫千’，21，‘f’,[‘摄影’‘吃’]]

#在student_info列表末尾追加一个值

Student_info.append(‘熬夜的老师，坦克’)

Print（student_info）

#6、删除

#删除列表中索引为2的值

Del student_info[2]

Print(student_info)

 

#需要掌握的

#6、extend合并列表

student_info1=['yhq',95,'f',['gw1','ky2'],95]
student_info2=['lyf',88,'f',['gf1','gy2']]

#把student_info2所有的值插入student_info1内
student_info1.extend(student_info2)
print(student_info1)

 

02、元组：

定义：

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

注意：

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

优点：

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

#定义
#tuple((1,2,3,'五','六'))
tuple1=(1,2,3,'五','六')
print(tuple1)
print(tuple1[2])
print(tuple1[0:5:3])
print(len(tuple1))
print(1 in tuple1)
print(1 not in tuple1)
for line in tuple1
    print(line,end='_')

03、可变类型与不可变类型:

      作用:

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

      定义:

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

 04、字典类型

dict1={'age':18,'name':'tank'}
print(dict1)
print(type(dict1))
print(dict1['age'])
#优先掌握操作：
#存一个level:9的值到dict1字典中
dict1['level']=9
print(dict1)
print(dict1['name'])
#2、长度len

#3、成员运算in和not in 只判断字典中的key
print('name'in dict1)#Ture
print('tank'in dict1)
print('tank'not in dict1)#Ture
#4、删除
del dict1['level']
print(dict1)
#5、键keys(),值values(),键值对items()
#得到字典中所有keys
print(dict1.keys())
#得到字典中所有values
print(dict1.values())
#得到字典中所有items
print(dict1.items())
#6、循环
#循环遍历字典中所有的key
for key in dict1:
        print(key)
        print(dict1[key])
        #get
        dict1={'age':18,'name':'tank'}
        print(dict1.get('sex'))
        print(dict1.get('sex','male'))

 

05 流程控制

‘’’

If判断

语法：

If判断条件

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

逻辑代码

Elif 判断条件：

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

逻辑代码

Else：

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

逻辑代码

，，，

，，，

while循环

语法：

While 条件判断：

#成立执行此处

逻辑代码

Break #跳出本层循环

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

，，，

# 判断两数大小
X = 10
Y = 20
Z = 30
# 缩进快捷键，tab往右移动四个空格，shift+tab往左移动四个空格
if X > Y:
    print(X)
elif Z > Y:
    print(Z)
else:
    print(Y)
    # 限制循环次数
name = 'tank'
    # 初始值
num = 0  # 0 1 2 3
    # while循环
while num < 3:
        name = input('请输入猜测的字符：').strip()
        if name == 'tank':
            print('tank success!')
            break
        print('请重新输入！')
        num += 1

 

06、文件处理：

Open（）

写文件

Wt:写文本

读文件

Rt:读文本

追加写文件

At：追加文本

注意：必须指定字符编码，以什么方式写就得以什么方式打开。

执行python文件的过程：

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

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

3、检测python语法，执行代码。

SyntaxError:语法错误！

 

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

1、python程序

2、操作系统打开文件

，，，

文件处理之上下文管理：

#with可以管理open打开的文件

会在with执行完毕后自动调用close（）关闭文件

With open()

,,,
文件处理之上下文管理
withopen（）as f '句柄'
，，，

,,,

对图片，音频，视频读写

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

#参数一：文件的绝对路径
#参数二：mode 操作文件的模式
#参数三：encoding 指定的字符编码
f=open('file.txt',mode='wt',encoding='utf-8')
f.write('tank')
f.close()#关闭操作系统文件资源
#写
with open ('file1.txt','w',encoding='utf-8')as f:
    f.write('墨菲定律')
#读
with open ('file1.txt','',encoding='utf-8')as f:
    res=f.read()
    f.write(res)
#追加
with open ('file1.txt','a',encoding='utf-8')as f:
    f.write('围城')
   # f.close（）
#读取相片cxk.jpg
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)
# 通过with来管理open打开的两个文件句柄f_r,f_w
with open('cxk.jpg', 'rb')as f_r, open('cxk_copy.jpg', 'wb')as f_w:
   # 通过f_r句柄把图片的二进制流读取出来
   res = f_r.read()
   # 通过f_w句柄把图片的二进制流写入cxk_copy.jpg文件中
   f_w.write(res)

 

，，，

07、函数形式

什么是函数?

函数指的其实一把工具。

 

使用函数的好处:

1.解决代码冗余问题。2.使代码的结构更清晰。3.易管理。

 

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

 

函数定义语法:

def函数名(参数1，参数2...）；

...注释:声明函数'''

逻辑代码

 

return返回值

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、空函数
#登录功能
def login():
    #代表什么也不做
 pass
#注册功能
def register():
    #代表什么也不做
    pass
#还款功能
def repay():
    pass

 

,,,

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

 

 

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

 

#不能多传

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

,,,

默认参数:

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

,,,

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

  print(x, y)

 

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

foo()

#传参，使用传入的参数

foo (200，300)

,,,

函数的嵌套定义:

在函数内部定义函数。

 

函数对象:

函数的名称空间

,,,

#函数的嵌套定义

def func1():...

,,,

函数的嵌套定义:

在函数内部定义函数。

 

函数对象:

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

 

函数的名称空间:

内置:

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

dic1 [choice] ( )

elif  choice == '2':

print(dic1[choice])

dic1 [choice]()

x=10

# 名称空间

#函数的嵌套定义

def func1() :

#x=20

print( 'from funcl...')

print(x)

def func2() : 

print('from func2...')

func1()

#名称空间

#函数的嵌套定义

def  func1() :

#x=20

print( 'from func1...')

print (x)#报错

X= 30

#代码是由上自下执行，print(x) 无法引用x= 30,所以报错

 

def func2() :

print( 'from func2...')

 

func1( )