'''
列表
  定义：在[]内，可以存放多个任意类型的值，并以逗号隔开。
一般用于存放学生的爱好，课堂的周期等等...
 '''
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

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

#需要掌握的：
student_info=['尹浩卿',95,'female',['尬舞','喊麦']]
#1.index获取列表中的某个值的索引
print(student_info.index(95) #1

#2.count获取列表中的某个值的数量
print(studen_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_info1=['尹浩卿',95,'female',['尬舞1','喊麦2'],95]
student_info2=['娄逸夫',94,'female',['尬舞1','喊麦2']]
#把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='_')

''''''
'''
不可变类型：
   数字类型  int float
    字符串类型  str
    元组类型  tuple
 可变类型：
    列表类型  list
   字典类型  dict
 '''
#不可变类型
number=100
print(id(number)) #1434810944
number=111
print(id(number))  #1434811296

#float
sal=1.0
print(id(sal)) #2771339842064
sal=2.0
print(id(sal)) #2771339841896

str1='hello python!'
print(id(str1)) #1975751484528
str2=str1.replace('hello','like')
print(id(str2)) #1975751484400

#可变类型
#列表

list1=[1,2,3]
list2=list1
list1.append(4)

#list1与list2指向的是同一份内存地址
print(id(list1))
print(id(list2))
print(list1)
print(list2)
'''
不可变类型：
   数字类型  int float
   字符串类型  str
   元组类型  tuple
可变类型：
   列表类型  list
   字典类型  dict
'''
#不可变类型
#int
number=100
print(id(number)) #1434810944
number=111
print(id(number))  #1434811296

#float
sal=1.0
print(id(sal)) #2771339842064
sal=2.0
print(id(sal)) #2771339841896

str1='hello python!'
print(id(str1)) #1975751484528
str2=str1.replace('hello','like')
print(id(str2)) #1975751484400

#可变类型
#列表

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['leve']=9
print(dict1) #{'age':18,'name':'tank','lever':9}
print(dict1['name']) #tank

#2.长度len

#3.成员运算in和not in 只判断字典中的key
print('name'in dict1)  #Ture
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()
#得到字典中所有值keys
printt(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)

'''
文件处理:
   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()

 

2019/6/25

1. 常用数据类型及内置方法
2. 文件处理
3. 函数

 

列表：

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

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

   优先掌握的操作：

1. 按索引存取值（正向存取+方向存取）：即可存也可以取
2. 切片（顾头不顾尾，步长）
3. 长度
4. 成员运算in和not in
5. 追加
6. 删除

   需要掌握的：

1. Index
2. count
3. Pop
4. Remove
5. Insert
6. extend

 

元组：

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

   注意：

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

   优点:

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

 

字典类型:

   作用：在{}内，可存放多个值，一key-value存取，取值速度快。

定义：key必须是不可变类型，value可以是任意类型。

 

if 判断：

   语法：

      if判断条件：

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

        逻辑代码

      elif 判断条件：

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

        逻辑代码

      else：

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

        逻辑代码

 

while循环

   语法：

      while条件判断：

          #成立执行此处

          逻辑代码

break  #跳出本层循环

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

 

文件处理:

   open()

   写文件

      wt:写文本

   读文件

      rt:读文本

   追加写文件

      at:追加文本

注意：必须指定字符编码(字集码，是把字符集中的字符编码为指定集合中的某一对象，以便文本在计算机中存储和通过通信网络的传递)

 以什么方式写，就得以什么方式打开。

 

 执行python代码的过程：

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

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

   3.检测Python语法，执行代码。

   SyntaxError:语法错误！

   

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

   1.python程序

   2.操作系统打开文件

 

文件处理之上下文管理：

1. with可以管理open打开的文件，会在with执行完毕后自动调用close()关闭文件

  with open()

1. with可以管理多个文件

 

 

四．函数

  什么是函数？

     函数指的其实一把工具。

  使用函数的好处：

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

 

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

  函数定义语法：

Def 函数名（参数1，参数2...）;

  ‘’’注释：声明函数’’’

  逻辑代码

 

  return 返回值

 

   def：defind 定义。

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

  ():接受外部传来的参数。

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

  Return:返回给调用者的值。

 

定义函数的三种形式：

  1.无参函数

    不需要接收外部传来的参数。

  2.有参函数

    需要接受外部传入的参数。

  3.空函数

Pass

 

位置参数：

  位置形参

  位置实参

  必须按照位置一一传参。

关键字参数：

   关键字实参

   按照关键字传参。

默认参数：

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

 

函数的嵌套定义：

  在函数内部定义函数。

函数对象

函数的名称空间:

  全局：

    所有顶着头写的变量、函数...都称之为"全局名称空间"。

  局部：

    在函数内部定义的，都称之为“局部名称空间”。

  名称空间加载顺序：

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

  名称空间查找顺序：

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