day2总结

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

'''

#定义一个学生列表,可存放多个学生
student=['傻屌 ','傻貂','傻吊','沙雕']
print(student[1])#傻貂

students_info =['杨波',84,'male',['泡吧','喝酒']]
#取杨波同学的所有爱好
print(students_info[3])
#取杨波同学的第二个爱好
print(students_info[3][1])


#1 按索引取值(正向存取+反向存取):即可存也可取
#正向

print(students_info[-2])  #杨波

#2 切片(顾头不顾尾,步长)
print(students_info[0:4:2])#[]

#长度
print(len(students_info))  #4

#4.成员运算in和not in
print('杨波' in students_info)
print('杨波' not in students_info)

#5追加
students_info =['杨波',84,'male',['泡吧','喝酒']]
students_info.append('安徽最牛的学员,合肥学院')

#6删除
#删除列表中索引为2的值
del students_info[2]
print(students_info)

#需要掌握的:
student_info = [' 尹浩卿’,95,’female', ['尬舞','喊麦'],95]
#并1. index获取列表中某个值的索引
print (student_info. index(95))# 1
# 2. count获取列表中某个值的数量
print (student_info. count (95)) # 2
# 3.取值,默认取列表中最后一个值,类似删除
#若pop()括号中写了索引,则取索引对应的值
student_info. pop()
print (student_info)
#取出列表中索引为2的值,并赋值给sex变量名
sex = student_info.pop(2)
print (sex)
print (student_info)

#4.移除,把列表中的某个值的第一个值移除
student_info.remove(95)
print(student_info) # [' 尹浩卿’,' female', [”尬舞’,'喊麦’了, 95]

name = student_info. remove('尹浩卿')
print(name)  #None
print(student_info) # [' female', [尬舞’,'喊麦', 95]

#5.插入值
student_info = [' 尹浩卿',95,'female', [' 尬舞','喊麦'],95]
#在student_ info中, 索引为3的位置插入  !合肥学院”
student_info. insert(3,'合肥学院')
print (student_info)

# 6. extend合并列表
student_infol = [' 尹浩卿',95, 'female', [' 尬舞1','喊麦2'],95]
student_info2 = [' 娄逸夫',94,'female', [' 尬舞1','喊麦2']]
#把student_ info2所 有的值插入student_ infoI内
student_infol.extend (student_info2)
print (student_infol)

'''
元组:
定义:
在()内,可以存放多个任意类型的值,并以逗号隔开。
注意:
元组与列表不一-样的是,只能在定义时初始化值,不能对其进行修改。
优点:
在内存中占用的资源比列表要小。
'''
#定义:
#tuple((1,2,3,'五','六'))
tuple1=((1,2,3,'',''))
print(tuple1)

#先掌握的操作:
# 1、按索引取值(正向取+反向取):只能取
print (tuple1[2]) #3
# 2、切片(顾头不顾尾,步长)
#从0开始切片到5-1, 步长为3
print(tuple1[0:5:3]) # (1,'五')

#3、长度
print(len(tuple1)) #5

#4、成员运算in和not in
print(1 in tuple1) # True
print(1 not in tuple1)# False

#5、循环
for line in tuple1:
  #print(line)
  #print默认end参数是\n
  print(line,end='_')

'''
不可变类型:
变量的值修改后,内存地址一定不一样。
数字类型
int
float
字符串类型
str
元组类型
tuple
元组类型:
tuple

可变类型:
    列表类型
      list
    字典类型
      dict
'''



#可变类型
#列表
list1=[1,2,3]
list2=list1
list1.append(4)

#list1与list2所指向的是同一份内存地址
print(id(list1))
print(id(list2))
print(list1)
print(list2)

'''
字典类型:
    作用:
        在{}内,以逗号隔开可存放多个值
        以key-value存取,取值速度快
    定义:
        key必须是不可变类型,value可以是任意类型
'''

#dict1=dict({'age':18,'name':'tank'})
dict1={'age':18,'name':'tank'}
print(dict1)    #{'age':18,'name':'tank'}
print(type(dict1))  #<class 'dict'>

#取值,字典名+[],括号内写值对应的key
print(dict1['age'])
#优先掌握的操作:
#1、按key存取值:可存可取
#存一个level:9的值到dict1字典中
dict1['level']=9
print(dict1)    #{'age':18,'name':'tank','level':9}
print(dict1['name'])    #tank

#2、长度len

#3、成员运算in和not in  只判断字典中的key
print('name'in dict1)   #True
print('tank'in dict1)   #False
print('tank'not in dict1)   #True

#4、删除
del dict1['level']
print(dict1)    #{'age':18,'name':'tank'}

#5、键keys(),值values(),键值对items()
#得到字典中所有key
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('age'))

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

#get取值
print(dict1.get('sex')) #None
#若找不到sex,为其设置一个默认值
print(dict1.get('sex','male'))

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

'''
while 循环
     语法:
          while 条件判断
                #成立执行此处
                逻辑代码
break  #跳出循环
continue   #结束本次循环,进入下一次循环
'''
str1= 'tank'

#while 循环
while true:
    name = input('请输入猜测的字符:').strip()
    if name == 'tank':
        print('tank success!')
        break
        print('请重新输入!')

#限制循环次数
str1 ='tank'
#初始值
num = 0 #0,1,2,3

#while 循环
while num<3:
    name = input('请输入爱测的字符: ').strip( )
    break;

print('请重新输入 !')
num+=1

'''
文件处理
    open()
     写文件
       vt:写文本
     读文件
       rt:读文本
     追加写文件
         at:追加文本
    注意:必须指定字符编码
    
    执行Python代码的过程
    1.先启动Python解释器,加载到内存中
    2.把写好的Python文件加载到解释器中
    3.检测Python语法,执行代码
    
    打开文件会产生两种资源:
     1.Python程序
     2.操作系统打开文件
    
 '''
#参数一:文件的绝对路径
#参数二:操作文件的模式
#参数三:encoding, 指定的字符编码
f=open('file.txt',mode='vt',encoding='utf-8')
f.write('tank')
f.close()#关闭操作系统文件资源


##读文本文件  r==rt
f=open('file.txt','r',encoding='utf-8')
print(f.read())
f.close()

#追加写文本文件
a=open('file.txt','a',encoding='utf-8')
a.write('\n 合肥学院')
a.close()

'''
文件处理之.上下文管理:
# with可以管理open打开的文件,
会在with执行完毕后自动调用close()关闭文件
with open()
'''

'''
文件处理之.上下文管理
with open() as f"句柄"
'''
#
with open('file1.tex','w',encoding='utf-8')as f:
      f.write('墨菲定律')

#
with open('file1.tex','r',encoding='utf-8')as f:
    res= f.read()
    print(res)

#追加
with open('file1.tex', 'w', 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.write(jpg)

'''
with 管理多个文件
'''
#通过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)

'''
四函数
什么是函数?
函数指的其实一把工具。

使用函数的好处:
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 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 reister():
    # 代表什么都不做
    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)

# 在调用阶段:10,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)

'''
函数的嵌套定义:
    在函数内部定义函数。
函数对象:
    函数的内存地址称之为函数对象。
函数的名称空间:
    内置:
        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 func1...')
    print(x)

    def func2():
        print('from func2...')


func1()

猜你喜欢

转载自www.cnblogs.com/hxssb/p/11087066.html