21天python入门 - 笔记

Python开发21天入门 - 笔记

1、基础知识

1.基本数据类型

​ 1.整型：int
​ py2：
​ -超出范围后，Python回自动将其转换long（长整型）
​ py3：
​ -所有整型均为int类型
​ 在py2中，整型的除法只能保留整数位，而py3保留所有
​ 2.布尔值(bool/boolean)
​ 只有两个值：
​ -true/false
​ 转换：
​ -数字转布尔：0是False；其他都是True
​ -字符串转布尔：“”是False；其他都是True
​ 3.字符串（str/string)

• 字符串特有的

​ .upper()/.lower():大小写转换

​ .isdigit()：判断是否是数字
​ .rstrip()/.lstrip()：去除左右边的空格
​ .replce(“被替换的字符/子序列”,“要替换的内容”)/ .replace(“被替换的字符/子序列”，“要替换的内容”，1)
​ .split(“根据什么东西进行分割”)/ .split(‘根据什么东西进行分割’,1) /rsplit

• 公共
  - len , 计算长度。（字符串->计算字符串的个数）

  - 索引取值 [] ---0作为开始
    						正值：从前往后取值
    						负值：从后往前取值
  - 切片 --- 0作为开始
    						v = "oldboy"
    						v1 = v[2:4]
    						v2 = v[3:]
    						v3 = v[:-1]
    						v4 = v[3:-1]
  

print(v1)
print(v2)
print(v3)
print(v4)
示例：
#需求：取最后两个字符
#方式一
data = input("请输入：")
v = data[-2:]
print(v)
#方式二
total_len = len(data)
data[total_len-2:total_len]
print(v)

2.码云使用

1. 组织使用
   -1，创建组织
   -2，邀请进入组织： 设置- 成员- 添加组织成员
   -3，加入组织
   -4，创建仓库：仓库名称，仓库介绍
   -5，如果有疑：Issues 进入自己的项目，点issues - 新建问题

2. 上传文件至码云
   -1，进入文件夹，右击，Git Bush Here
   -2，进行设置
   git init --初始化
   git config – global user.email"…@qq.com" --设置邮箱
   git config --global user.name"wcc342425" --设置用户名
   git remote add origin http://码云地址 --添加码云地址
   git push origin master --上传文件
   提示：输入用户名和密码（码云）

3. 提交文件至码云

   • 进入需要提交的文件目录

   1. 右击，Git Bush Here

   2. git status — 查看当前目录状态

   3. git add . — 收集文件，执行完成后，变成绿色

   4. git commit -m ‘第三天作业’ —写入提交记录

   5. git push origin master —上传文件

      [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-CE6E8rDL-1572352415138)(C:\Users\Administrator\AppData\Roaming\Typora\typora-user-images\1570535869103.png)]

• 提交文件上时，忘记提交其他文件

  ​ git status

  ​ git add.

  ​ git commit -m ‘描述性文字’

  ​ git push origin master

• 第一次配置码云

  [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-u87R5ddp-1572352415148)(C:\Users\Administrator\AppData\Roaming\Typora\typora-user-images\1570535943455.png)][外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-ZtdBTDaw-1572352415150)(C:\Users\Administrator\AppData\Roaming\Typora\typora-user-images\1570535955958.png)]

  • 公司如何用git做开发？

    1. 在码云或者是GitHub等代码托管的网站创建自己的仓库，创建之后码云会给我一个仓库地址。如：https://gitee.com/wcc342425/python_study.git

    2. 自己在本地写代码

    3. 将代码提交到远程仓库

       • 初始化

         • 进入一个任意文件夹

         • git init

         • git config 邮箱

         • git config 姓名

         • git remote add origin https://gitee.com/wcc342425/python_study.git

           注意：至此git已经将文件夹目录管理起来，以后此文件夹有任何变化，git都会检测到（使用git status命令可以查看状态）

       • 代码收集并提交

         • git status
         • git add .
         • git commit -m “记录”
         • git push origin master – 将本地文件夹目录下的内容同步到码云仓库

       • 修改代码或删除文件等对本地文件夹下任何文件进项操作

         • git status
         • git add .
         • git commit -m “记录”
         • git push origin master – 将本地文件夹目录下的内容同步到码云仓库

       • 【避免】如果远程有本地没有的代码，必须先执行：【可能会引发合并问题】

         • git pull origin master
         • git status
         • git add .
         • git commit -m “记录”
         • git push origin master – 将本地文件夹目录下的内容同步到码云仓库

3.需要完成

​ 1，思维导图
​ 2，笔记，博客

4.补充

• encode – 编码

• format – 格式控制

• join – 循环每个元素，并在元素和元素之间加入连接符

• for循环：

  name = 'alex'
  for item in name :
      print(item)
  

  name = 'alex'
  for item in name:
      print(item)
      break
      print('123')
  

  name = 'alex'
  for item in name:
      print(item)
      continue
      print('123')
  

  注意：1.以for循环打印字符串的每个元素： for > while

  ​ 2.死循环 ：while > for

  • range（） – 帮助生成某范围区间的数字，前取后不取

    ​ range（1,11） – 1，2 ，3,4,5,6,7,8，9,10

    for i in range(1,11):
        if i == 7:
            pass
        else:
            print(i)
    

2. 数据类型

1.列表 - list

若想要表示多个"事物"，可以使用列表。

user = ["李少奇"，"李启航"，99]

1. 公共功能

• len

  users = ["李少奇"，"李启航"，99]
  val = len(users)
  print(val) # 3
  

• 索引

  users = ["李少奇"，"李启航"，99]
  val = users[0]
  

• 切片

  users = ["李少奇"，"李启航"，99]
  val = users[0:2]
  

• 步长

  users = ["李少奇"，"李启航"，99]
  val = users[0:2:2]
  

• for循环

  ## 1. for循环
  users = ['李少奇','李启航','张三丰', '李子树']
  for i in users:
      print(i)
  
  for i in users:
      for ele in i :
          print(ele, end= ' ')
      print(' ')
  
  #练习题： 请通过for循环和数字计数器实现：users = ['李少奇','李启航','张三丰', '李子树']
  '''
      0 李少奇
      1 李启航
      2 张三丰
      3 李子树
  '''
  #方式一
  count = 0
  for i in users:
      print(count , i)
      count += 1
  
  #方式二
  users_len = len(users)
  for index in range(0, users_len):
      print(index, users[index]) 
  

• 删除

  users = ['李少奇', '起航', 99]
  #方式一
  users.pop[1]
  print(users)
  
  #方式二
  del users[1]
  print(users)
  

  注意：字符串本身不能被修改或删除【不可变类型】

  ​ 列表是可变类型

• 修改（字符串、数字、布尔除外）

  users = ['李少奇', '起航', 99]
  users[2] = 66
  
  users[0] ='wcc'
  
  users[0][1]  # --  不可被修改
  

• extend() – 添加/插入

  '''
  1.有列表    users= ['李忠伟','唐开发']  people = ['李鹏','张师傅']
      users.extend(people)    #users中增加
      people.extend(users)    #people中增加
  
  2.有列表    users= ['李忠伟','唐开发']  元组：people = ('李鹏','张师傅')
      users.extend(people)    #users中增加
      people.extend(users)    #只有列表有extend功能，元组是没有的
  '''
  

2.练习题

​ - 整数加法计算器

'''
实现一个整数加法计算器（两个数相加）
如：content = input （“请输入内容”），用户输入5+9或5+ 9，或5 + 9，然后进行分割转换最终进行整数的计算得到结果
'''

content = input('请输入：') # 5+9或5+ 9，或5 + 9
# 思路一：
content = content.strip()
v1 = int(content[0])
v2 = int(content[-1])
v3 = v1 + v2

#思路二：
content_len = len(content)
index = 0
total = 0
while True:
    char = content[index]
    if char.isdigit():
        total += int(char)
    index += 1
    if index == content_len:
        break
print(total)

#思路三：
result = content.split()
print(result)   #['55', '+99']
v1 = int(result[0])
print(v1)# 55
v2 = int(result[-1])
print(v2)   # 99
v3 = v1 + v2
print(v3)

3.独有功能 - 方法

• append() – 在列表最后追加元素

  users = []
  users.append('wcc')
  print(users)
  
  

## 示例一：
#1. 在列表最后追加一个元素
users = []
while True:
    mane = input("请输入姓名：")
    users.append(mane)
    print(users)

### 示例二：
#录入用户名和密码
for i in range(0, 3):
    name = input("请输入姓名：")
    result = users.append(name)
print(users)

#用户名和密码进行校验
username = input("请输入用户名：")
password = input("请输入密码")
for item in users:
    result = item.split(',')
    user = result[0]
    pwd = result[1]
    if user == username and pwd == password:
        print("登录成功")
        break

• insert – 在指定索引位置进行插入元素

  users = ['李少奇','李启航','张三丰', '李子树']
  users.insert(1, 'wcc')
  print(users)	#['李少奇', 'wcc', '李启航', '张三丰', '李子树']
  
  

• remove – 删除

  users = ['李少奇','李启航','张三丰', '李子树']
  users.remove('张三丰')
  print(users)	#['李少奇', '李启航', '李子树']
  
  

• pop – 删除，将被删除的数据赋值给变量

  users = ['李少奇', '张三丰','李启航','张三丰', '李子树']
  # users.pop(1)
  users.pop() #不加，默认删除最后一个
  print(users)	#['李少奇', '张三丰', '李启航', '张三丰']
  
  

• clear – 清空

  users = ['李少奇', '张三丰','李启航','张三丰', '李子树']
  users.clear()
  print(users)	#[]
  
  

• del – 删除

4.总结

• 增

  append / insert

• 删

  remove / pop / clear / del users[2]

• 改

  users[3] = “新值”

• 查

  索引 / 切片

• 列表的嵌套

  user = ["alex", 0,True,[11,22,33,"老男孩"],[1,['alex','oldboy']2,3]]
  user[0]
  user[2]
  user[0][2]
  user[3]	#[11,22,33,"老男孩"]
  user[3][-1]	#"老男孩"
  user[3][-1][1]	#'男'
  user[3] = 666
  
  

  5,列表补充

  • 反转:reverse
    • reverse = Flase – 从小到大（默认）
    • reverse = True — 从大到小
  • 排序：sort

2.元祖 - tuple

1, 元祖书写规范

user = [11,22,33,'老男孩']  	 # -- 列表（可变）
user = (11,22,33,'老男孩')	 # -- 元祖（不可变）

2,公共功能

​ 1，索引 （排除：int / bool)

​ 2，切片（排除：int / bool)

​ 3，步长（排除：int / bool)

​ 4，删除 （排除：tuple / str / int / bool）

​ 5，修改 （排除：tuple / str / int / bool）

​ 6，for循环（排除：int / bool)

​ 7，len（排除：int / bool)

users = (11, 22, 33, "老男孩")
#索引
print(users[0])
print(users[-1])

#切片
print(users[0:2])

#步长
print(users[0:2:2])

#for 循环
for item in users:
    print(item)

#len
print(len(users))

3,特殊

元祖中的元素（儿子）不可被修改 、删除

#示例一：
v1 = (11,22,33)
v1[1] = 999 	#错误
v1 = 999 		#正确

#示例二：可以嵌套
v1 = (11,22,33(44,55,66),(11,2,(11,99),2))

#示例三：嵌套
v2 = [11,22,33(44,11,33)]
v1[-1][1] = 99 	#错误
v2[-1] = 123 	#正确

#示例四：嵌套
v3 = (11,[2,3,4],22,33)
v3[1] = 666 	#错误
v3[1][2] = 123	#正确

4,总结

• 列表（可变）

  • 公共
    • 索引、切片、步长、修改、删除、for、len
  • 独有
    • append、insert、pop、remove、clera
  • 列表嵌套

• 元祖（不可变）

  • 公共

    • 索引、切片、步长、for、len

  • 独有功能 ---- 无

  • 元祖嵌套

    v3 = (11,[2,3,4],22,33)
    v3[1] = 666 	#错误
    v3[1][2] = 123	#正确
    
    

• 类型转换

   '''
   字符串转数字
   数字转字符串
   列表转元组
   元组转列表
   '''
  
  

  #练习题： join连接时，元素必须是字符串
  num = [11,22,33,44]
  for i in range(0, len(num)):
      num[i] = str(num[i])
  result = '_'.join(num)
  print(result)
  
  

  注意："".join([元素必须是字符串，元素必须是字符串，])

3.字典 - dict

帮助用户去表示一个事物的信息（事物是有多个属性）

info = {"name":"liwei","age":14,"gender":"男","hobby":'同桌'}  # 键值

1,基本格式

data = {键：值，键：值，键：值，键：值，键：值}

#示例：
userinfo = {'username':'alex','password':'oldboy'}
user = input('请输入用户名：')
pwd = input('请输入密码')
if userinfo['username'] == user and userinfo['password'] == pwd:
    print('登陆成功')
else:
    print ('用户名或密码错误')

2, 独有功能 - 方法

• keys ， 获取字典中所有的键 — [‘name’,‘age’,‘gender’,‘hobby’]

  for item in info.keys():
      print(item)
  
  

• values ， 获取字典中所有的值

  for item in info.values():
      print(item)
  
  

• items ， 获取字典中的所有键值对

  for v1,v2 in info.items():
      print(v1,v2)
  
  

3,公共功能

• len

  info = {"name": "liwei", "age": 14, "gender": "男", "hobby": '同桌'}
  print(len(info))
  
  

• 索引

  info = {"name": "liwei", "age": 14, "gender": "男", "hobby": '同桌'}
  print(info['name'])
  print(info['age'])
  
  

• for 循环

• 修改 — 存在就修改，不存在就增加

  ## 改值
  info = {"name": "liwei", "age": 14, "gender": "男", "hobby": '同桌'}
  info['age'] = 12
  print(info)
  ## 改键 ---  删除后再增加
  del info['hobby']
  info['xxxx'] = 'xxx1'
  
  

• 删除 ---- 键值对 作为一个整体，要删就全部删除

  info = {"name": "liwei", "age": 14, "gender": "男", "hobby": '同桌'}
  del info['name']
  print(info)
  
  

4,总结

• 重点： int 、 bool 、 str 、 list 、 tuple 、 dict

5,字典补充

• .get() — 取值，与索引的区别是，get()若字典中存在，则取值；若不存在，也不会报错，会返回None

  None数据类型，该类型表示空（无任何功能，专门用于提供空值）

• .update – 不存在，则添加；存在，则更新

• 判断一个字符串是否有敏感字符

  • str

    v = 'python全栈21期'
    if '全栈' in v:
        print('包含敏感词汇')
    
    

  • list

    v = ['alex','oldboy','canglaiosh','kliqihang']
    if 'liqihang' in v:
        print('包含敏感词汇')
    
    

  • dict

    v = {'k1':'v1','k2':'v2','k3':'v4'}
    #默认按照建判断，即：判断x是否是字典的建
    if 'x' in v:
    	pass
    #请判断：k1是否在其中？
    #方式一：循环判断
    flag = '不存在'
    for v in v.values():
    	if v == v2:
    	flag = "存在"
    print(flag)
    #方式二：
    if 'v2' in list(v.values（）) #强制转换改成列表 ['v1','v2','v3']
    	pass
    
    

  • 练习题

    #让用户输入任意字符串，然后判断次字符串是否包含指定的敏感字符
    char_list == ['李启航','唐油光','渣渣辉']
    content = input('请输入内容')
    success = True
    for v in char_list:
        if v in content:
            print('包含敏感字符')
            success = False
            break
    if success:
        print(content)
    
    

4.集合 — set

无序的，且不可重复的

v = {1,2,3,4,5,6,4,5,}
### 注意：
v = {}  #空字典
print(type(v))

v1 = set()  #空集合
print(type(v1))

1.集合独有功能 - 方法

add 、 discard 、 update 、 intersection 、 union 、 difference

# ###  1，空集合
# v = {}  #空字典
# print(type(v))#
# v1 = set()  #空集合
# print(type(v1))
# #2,独有功能
# # 2.1 add 添加
# v = {1,2}
# v.add('ads')
# v.add('ads')   # 集合不可重复添加
# print(v)
# # 2.2 删除
# v= {1,2,'lishaoqi'}
# print(v)
# v.discard('lishaoqi')
# print(v)
##2.3 update -- 往里面批量添加
# v= {1,2,'lishaoqi'}
# v.update({11,22,33})
# print(v)
## 2.4 交集  ---- 生成新的值
# v= {1,2,'lishaoqi'}
# result = v.intersection({1,'lisahoqi'})
# print(v)
# print(result)
#2.5 并集
# v= {1,2,'lishaoqi'}
# result = v.union({1,'lishaoqi','xiaoghe'})
# print(v)
# print(result)
# # 2.6 差集
# v= {1,2,'lishaoqi'}
# result = v.difference({1,'lishaoqi','xiaohei'}) # v中有且后者没有
# print(v)
# print(result)
####注意：
# v= {1,2,'lishaoqi'}
# result = v.intersection([1,'lisahoqi'])#可以是列表等
# print(v)
# print(result)

2.公共功能

• len，for循环 — 有的
• 索引，步长，切片，删除，修改 ---- 没有的

3.集合嵌套

- 列表、字典、集合 --> 不能放在集合中+ 不能作为字典key（unhashable）

5.内存相关

1,查看内存地址

​ 通过id()可以来查看内存地址

2,特殊

​ 1，整型： -5 ~256

​ 2， 字符串：“Alex”，‘sadd’ ------ “f_*” * 3 – 重新开辟内存

3,== 和 is 的区别

- == 用于比较值是否相等
- is 用于比较内存地址是否相等

6,深浅拷贝

1,int + str + bool + tuple

深浅拷贝是一样的

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-OCal9S58-1572352415158)(C:\Users\Administrator\AppData\Roaming\Typora\typora-user-images\1570795062455.png)]

2,list + set + dict

• 只有一层情况下深浅拷贝是一样的
• 嵌套两层以上，深浅拷贝是不一样的

3,总结

• 浅拷贝：拷贝第一层

• 深拷贝：拷贝所有数据(可变)

  # 1，str + int + bool
  v1 = 'alex'
  import copy
  v2 = copy.copy(v1)
  print(id(v1),id(v2))
  
  v3 = copy.deepcopy(v1)
  print(id(v1), id(v3))
  
  # 2,list + tuple + set  -- 无嵌套
  v1 = [1,2,3,4]
  import copy
  v2 = copy.copy(v1)
  print(id(v1),id(v2))
  
  v3 = copy.deepcopy(v1)
  print(id(v1), id(v3))
  
  #3,list + tuple + set  -- 嵌套
  v1 = [1,2,3,4,[11,22,33]]
  import copy
  v2 = copy.copy(v1)
  print(id(v1),id(v2))
  print(id(v1[4]),id(v2[4]))
  
  v3 = copy.deepcopy(v1)
  print(id(v1), id(v3))
  print(id(v1[4]),id(v2[4]))
  
  

浅拷贝 - 只拷贝第一层；深拷贝 - 拷贝层次里面的所有的可变类型，不可变类型都不拷贝

3.文件操作

1,打开 - open

• r – 只读不能写；若文件不存在，则报错【**】

#  1  打开文件
file_object = open('log.txt', mode='r',encoding='utf-8')  # w =  write , r = read ,a = append

#读取文件
content = file_object.read()
print(content)

#关闭文件
file_object.close()

• w – 只写不能读，会先清空文件 ； 文件不存在，则新建 【**】

• a – 用于写入文件，在原文件尾部添加新内容 ； 若文件不存在，则新建 【*】

  ## 写入文件
  
  # #打开文件
  # file_object = open('log.txt', mode='w',encoding='utf-8')  # w =  write（只写 - 先清空，一般用于新建文件） , r = read ,a = append
  #
  # #写入文件
  # file_object.write('长春')
  #
  # #关闭文件
  # file_object.close()
  #
  #打开文件
  file_object = open('log.txt', mode='a',encoding='utf-8')  # w =  write（只写 - 先清空，一般用于新建文件） , r = read ,a = append
  
  #写入文件
  file_object.write('长春')
  
  #关闭文件
  file_object.close()
  
  
  

• r+ ： 可读可写，

  • 读取：默认从最开始位置（0）开始读，也可以通过seek调整光标的位置
  • 写入：根据光标的位置，从当前光标位置开始进行写入操作（可能会将其他的文字覆盖）
    • seek - 改变光标位置

• w+

  • 读：默认光标永远在写入的最后或0，也可以通过seek调整光标的位置
  • 写：光标先清空

• a+

  • 读：默认光标在最后，也可通过seek调整光标的位置，然后去读取
  • 写：永远写在最后

2,操作

• 读文件

  • read()
  • read(2) #字符
  • readlines()

  file_object = open('log.txt', mode='r',encoding='utf-8')
  
  #读取文件的所有内容到内存
  data = file_object.read()
  
  #从当前光标所在的位置向后读取文件的前两个字符
  data = file_object.read(2)
  
  #读取文件的所有内容到内存，并按照每一行进行分割到列表中
  data = file_object.readline()
  
  #如果以后读取一个特别大的字符(*****************)
  for line in file_object:
      line = line.strip()
      print(line)
  
  file_object.close()
  # print(data)
  
  
  

• 写

  • write

  #####x写
  file_object = open('log.txt', mode='w',encoding='utf-8')
  file_object.write('adsda\n')
  file_object.write('sadsada\n')
  
  file_object.close()
  
  

3,关闭 - close

4,文件总结

#打开文件
f = open('要打开的文件路径', mode = 'r/w/a',encoding = '文件原来写入时定义的编码')

#操作
data = f.read()   # 读取文件的内容到内存（全部）
f.write('要写入的内容')

# 关闭文件
f.close()

# 示例第一   ----    一般用于文字的写入
f = open('a.txt', mode = 'w',encodingg = 'utf-8')

#a.将'你好', 根据encoding指定的编码转换成二进制
#b.将二进制写入到文件中
f.write('你好')   # w 打开文件，则write传入字符串
f.close()

###示例二   -----     一般用于图片、音频、视频、未知编码
f = open('a.txt', mode = 'wb')  # wb打开文件，则需要直接传入二进制
#1，将要写入的字符串转换成二进制
data = '我好困'
content = data.encode('utf-8')
print(content)
#2，再讲二进制写到文件中
f.write(content)
f.close()

f = open('a.txt', mode = 'rb')
#直接读取到的是二进制的数据
data = f.read()
f.close()
print(data)

文件操作

• 模式

  • r/a/w （只读只写字符串）

  • r+ / w+ / a+（可读可写字符串）

  • rb / wb / ab （只读只写二进制）

    • 字符串转换’二进制‘

      v = “你好”

      data = v.encode(‘utf-8’)

    • 二进制转换成字符串

      v = b’\xe6\x88\x91\xe5\xa5\xbd\xe5\x9b\xb0’

      data = v.decode(‘utf-8’)

4,函数

1,三元运算（三目运算）

v = 前面 if 条件 else 后面
# 相当于下面 的代码：
if 条件：
	v = 前面
 else： 
	v = 后面

#  让用户输入值，如果是整数，则转换成整数，否则赋值为None

data = input('>>>')
value = int(data) if data.isdecimal() else None

2,函数基础

• 本质：将N行代码拿到别处并给他起个名字，以后通过名字就可以找到这段代码并执行
• 场景
  • 代码重复执行
  • 代码量特别多，超过一屏，可以选择通过函数进行代码的分割

1,函数的基本结构

#函数的定义
def 函数名():	#函数名 同变量名命名规则一样
    #函数内容
    pass

#函数的执行
函数名()

def get_list_first_data():
    v = [11,22,33,44]
    print(v)
    
get_list_first_data()

2,函数参数

# 参数基本结构
def get_list_first_data(aaa):   #  aaa 叫形式参数
    data = [11, 22, 33, 44]
    print(data[aaa])

get_list_first_data(1)      #2,1 等  调用函数时，叫实际参数
get_list_first_data(2)
get_list_first_data(3)
get_list_first_data(0)

练习题

#1，请写一个函数，函数计算列表info = [11,22,33,44,55]中所有元素的和
def sum_info():
    info = [11, 22, 33, 44, 55]
    print(info)
    sum = 0
    for i in rinfo:
        sum += i
    print(sum)

sum_info()

#2,请写一个函数，函数计算列表中所有元素的和
def get_list_sum(a1):
    data = 0
    for item in a1:
        data += item
    print(data)

get_list_sum([11,22,33])
get_list_sum([11,22,33,44])

#3, 请写一个函数，将两个列表拼接起来
def join_list(a1,a2):
    result = []
    result.extend(a1)
    result.extend(a2)
    print(result)

join_list([11,22,33],[12,34])

3,函数返回值

def func(arg):
    #....
    return 9 # 返回值为9，默认：return None

val = func('dasda')

#1,让用户输入一段字符串，计算字符串中有多少个A的个数，有多少个就在文件a.txt中写多少个'李劭祺'
def get_char_count(data):
    sum_counter = 0
    for i in data:
        if i == "A":
            sum_counter += 1
    return sum_counter

def write_file(line):
    if len(line) == 0:
        return False    #函数的执行过程中，一旦遇到return，则停止函数的执行
    with open('a.txt', mode= 'w',encoding='utf-8') as f:
        f.write(line)
    return True


content = input("请输入")
counter = get_char_count(content)
write_data = '李劭祺' * counter
status = write_file(write_data)
if status:
    print("successful")
else:
    print("error")

4总结

#情况1
def f1():
    pass
f1()
#情况2
def f2():
    pass
f2()
#情况3
def f3():
    return 1
v1 = f3()
#情况4
def f4(a1,a2):
    return a1+a1
v2 = f4(4,1)

5,练习题

# 1， 写函数，检测 计算一个列表中有多少个数字，最终打印：列表中有%s个数字
#提示：type('x') == int  判断是否是数字

def number(list):
    count =0
    for item in list:
        if type(item) == int:
            count += 1
    return count

    # print("列表中有%s个数字"%(count,))

# list_input = input("请输入列表：")
list_input = [11,22,'a','c']
a = number(list_input)
print("列表中有%s个数字"%a)

#2,写函数，计算一个列表中偶数索引位置的数据构造成另外一个列表，并返回
'''def get_oeder(li):
    list = []
    for i in range(0,len(li),2):
       # list = list.extend(int(i))
        list.append(li[i])
    print(list)

lis = [1,2,3,4,5,6,6,7,'a',9]
get_oeder(lis)
'''

def data_list1(arg):    # 切片
    v = arg[::2]
    return v
data =data_list1([11,223,4,55,2])
print(data)

#3， 读取文件，将文件的内容构造成指定格式的数据，并返回
'''
a.log文件
    alex|123|12
    eric|uiuf|13
    ...

目标结构：
a = ['alex|123|12","eric|uiuf|13"]并返回
b = [['alex|123|12"],["eric|uiuf|13"]]
c = {
        {'name':'alex,'pwd':123,'age':'12'}
        {'name':'eric,'pwd':uiuf,'age':'13'}
    }
'''

3,函数参数

1,基本参数知识

• 任意个数

• 任意类型

  def func(a1,a2,a3):
      print(a1,a2,a3)
  func(1,'ad',Ture)
  
  

2,位置传参

​ 调用函数并传入参数

def func(a1,a2):
    print(a1,a2)

func(1,2)

3,关键字传参

def func(a1,a2):
    print(a1,a2)

func(a2 = 99, a1 = 22)


# 关键字传参和位置传参可以混合使用   (位置传入的参数 > 关键字参数  在后  =  总参数个数)

def func(a1,a2,a3):
    print(a1,a2,a3)

func(11,22, a3 = 22)

4,默认参数【定义时】

def func(a1,a2 = 9):
    pass
"""
func 函数接受两个参数，调用函数进行传值时：
	func(1,2)
	func(1,a2 = 12)
	
"""

5,万能参数（打散）

• *args 可以接受任意个数的参数，并将参数转换成元组
  • 有 *
  • 无 *
  • 只能有位置传参，不能用关键字传参

def func(*args):
    print(args)

func(1)
func(1,2)
func(1,2,[11,22,33],12312,55,"true",'alex')
func((11,22,33,44,55))
func(*(11,22,33,44,55))    

• **kwargs : 可以接受任意个数的关键字参数，并将参数转换成字典

  • 只能有关键字传参
  • 调用函数 无 **

  def func(**kwargs):
      print(kwargs)
  
  func(k1 =1, k2 = 'alex')
  
  

  • 调用函数 有 **

    def func(**kwargs):
        print(kwargs)
    
    func(**{'k1' :'1', 'k2' : 'alex'})	#{'k1': '1', 'k2': 'alex'}
    
    

• 综合应用

  def func(*args,**kwargs):
      print(args,kwargs)
  
  func(1,2,3,4,5,k1 = 2,k2 = 43,k3 = 999)  #(1, 2, 3, 4, 5) {'k1': 2, 'k2': 43, 'k3': 999}
  
  

6,参数相关重点

• 定义函数

def func(a1,a2):
    pass

def func2(a1,a2 = None):
    psss
    
def func3(*args,**kwargs):
    pass

• 调用函数

  位置参数 > 关键字参数

4,作用域

• 全局作用域 — 以后必须全部大写
• 局部作用域
• 总结
  • 一个函数就是一个作用域
  • 作用域中查找数据的规则：优先在自己的作用域找数据，自己没有就去"父级"->"父级"直到全局，没有就报错。注意：父级作用域中的值到底是什么
  • 子作用域中只能 找到 父级中的值，默认 无法为父级的变量重新赋值；如果非要为父级变量进行赋值，则使用global关键字（global直接找到全局关键字，nonlocal 找到上级关键字）

5,函数小高级

1.函数赋值

- 函数名可以当做变量使用

def func():
    print(123)

v1 = func

func()
v1()

def func():
    print(123)

func_list = [func,func,func]
func_list[0]()
func_list[1]()
func_list[2]()

for item in func_list:
    item()

####### 容易混淆
def func():
    # print(123)
    return 123

func_list1 = [func,func,func]
func_list2 = [func(),func(),func()]
print(func_list2)

• 函数可以当做参数进行传递

def func(arg):
    # print(arg)
    v1 = arg()
    print(v1)


def show():
    print(666)

func(show)

2,lanbda表达式 – 匿名函数

用于表示简单的函数

# 三元运算，为了坚决简单的if else 的情况，如：
if 1 == 1：
	a = 213
else :
    a = 2333

a = 123 if  1 ==1 else 342

#lambda 表达式，为了解决简单函数的情况，如：
def func1(a1, a2):
    return a1 + 100

func2 = lambda  a1,a2:a1+100

func1 = lambda : 100

func2 = lambda x1,:x1 * 10

func3 = lambda *args,**kwargs:len(args)+ len(kwargs)

func4 = lambda n1,n2:n1 if n1 > n2 else n2

########### 总结：列表所有方法基本上都是返回None；字符串的所有方法都是返回新值
#练习题1
USER_LIST = []
func1 = lambda x:USER_LIST.append(x)

v1 = func1("alex")
print(v1)
print(USER_LIST)

#练习题2
def func0(x):
    v = x.strip()
    return v

result = func0("  alex")

print(result)

3,内置函数

• 自定义函数
• 内置函数
  • 其他
    • len
    • open
    • renge
    • id
    • type
  • 输入输出
    • input
    • print
  • 强制转换
    • dict()
    • list()
    • tuple()
    • int()
    • str()
    • bool()
    • set()
  • 数学相关
    • abs ：绝对值
    • float ：转换成小数
    • max / min ： 最大最小值
    • sum： 求和
    • divmod： 两数相除，得商和余数

4,分页

#练习题：分页
USER_LIST= []
for i in range(1,856):
    temp = {'name':'nishaoqi-%s'%i,'email':'[email protected]%s'%i}
    USER_LIST.append(temp)
#请通过分页对数据进行展示
"""
要求：
    每页显示10条数据
    让用户输入哟啊查看的页面：页码
"""
#数据总总条数
total_cont = len(USER_LIST)

#每页显示10条
per_page_count =10

#总页码数
max_page_num,a = divmod(total_cont,per_page_count)
if a > 0:
    max_page_num +1
pager = int(input("要查看第几页"))
if pager < 1 or pager >max_page_num:
    print("页码不合法，必须是1~%s"%max_page_num)
else:
    """
    #第1页：USER_LIST[0:10]
    #第2页：USER_LIST[10:20]
    #第3页：USER_LIST[20:30]
    #第4页：USER_LIST[30:40]
    ....
    """
    start = (pager -1)* 10
    end = pager*per_page_count
    data = USER_LIST[start:end]
    for item in data:
        print(item)

5,进制转换

• bin： 将十进制转换成二进制

  num = 15
  v = bin(num)
  print(v)
  
  

• oct：将十进制转换成八进制

  num = 8
  v = oct(num)
  print(v)
  
  

• int： 将其他进制转换成十进制

  ### 二进制转换成十进制
  v1 = '0b1110'
  result = int(v1,base = 2)
  print(result,bin(result))
  
  ### 八进制转换成十进制
  v1 = '0o1110'
  result = int(v1,base = 8)
  print(result,bin(result))
  
  ### 十六进制转换成十进制
  v1 = '0x1110'
  result = int(v1,base = 16)
  print(result,bin(result))
  
  

• hex：将十进制转换成十六进制

  num = 16
  v = hex(num)
  print(v)
  
  

6,面试题

# 1字节等于8位
#IP ： 192.168.12.79  -> 001010010.001010010.001010010.001010010
#请将ip = "192.168.12.79"中的每个十进制转换成二进制，并通过，链接起来，生成一个新的字符串
ip = "192.168.12.79"
ip_list = ip.split('.')  #['192','168','12','79']
result = []
for item in ip_list:
    result.append(bin(int(item)))
print(','.join(result))	#0b11000000,0b10101000,0b1100,0b1001111

## 2.请将ip = "192.168.12.79"中的每个十进制转换成二进制：
##  0b11000000,0b10101000,0b1100,0b1001111  -> 十进制的值

6,函数中高级

1,函数可以做返回值

def func():
    print(1232)

def bar():
    # print(func)
    return func
v = bar()

v()

2,闭包

闭包：为函数常见一块区域（内部变量），并为其维护自己数据，为以后执行提供数据

应用场景：装饰器， SQLAlchemy源码

def func(name):
    def inner():
        print(name)
    return inner

v1 = func('alex')
v1()

v2 = func('eric')
v2()

#不是闭包
def func1(name):
    def inner()：
    	return 123
    return inner

#是闭包：封装值 +  内层函数需要使用
def func2(name):
    def inner():
        print(name)
        return 12
    return inner

3,高阶函数

• 把函数当做参数传递
• 把函数当做返回值

注意：对函数进行赋值

7,内置函数–编码相关

1,编码转换

• chr ： 将十进制数字转换成Unicode编码中对应字符串

  v = chr(65)
  print(v)
  
  

• ord ： 根据字符在Unicode编码中找到其对应的十进制

  num = ord('中')
  
  

2,随机验证码

import random

def get_random_code(length = 6):
    data = []
    for i in range(6):
        v = random.randint(65,90)
        data.append(chr(v))

    return ''.join(data)

code = get_random_code()
print(code)

import random  # 导入一个模块

v = random.randint(起始，终止) #得到一个随机数

3,高级内置函数 - 面试

• map : 循环每个元素（第二个参数），然后让每个元素执行函数（第一个参数），将每个函数执行的结果保存到新列表中，并返回。

  v1 = [11,22,33,44]
  #第一个参数：必须是一个函数
  #第二个参数必须是：可迭代类型（可以被for循环）
  # def func(arg):
  #     return arg + 100
  # result = map(func,v1)   # 将函数的返回值添加到 [None,]
  # print(list(result))
  
  result = map(lambda x:x+100,v1)
  print(result)   #[111, 122, 133, 144] -- py2
  print(list(result))   #特殊  -- py3
  print(v1)  	#map 操作不影响 v1
  
  

• filter ：

  v1 = [11,22,33,'asd',44,'xf']
  def func(x):
      # if type(x) == int:
      #     return True
      # return False
  
  
      # return True if type(x) == int else False
  
      # return type(x ) == int
  
  
  result = filter(func,v1)
  print(list(result))
  
  

• reduce — 累乘、累加等操作

  import  functools
  
  v1 = [11,22,33]
  
  def func(x,y):
      return x+y
  
  result = functools.reduce(func,v1)
  print(result)
  
  

5.模块

1,md5 加密

​ getpass

​ hashlib

​ random

import hashlib

def get_md5(data):
    obj = hashlib.md5()
    obj.update(data.encode('utf-8'))
    result = obj.hexdigest()
    return result

val = get_md5('123')
print(val)

• 加盐

  import hashlib
  
  def get_md5(data):
      obj = hashlib.md5('sadsa'.encode('utf-8'))
      obj.update(data.encode('utf-8'))
      result = obj.hexdigest()
      return result
  
  val = get_md5('123')
  print(val)
  
  

• 应用

  import hashlib
  User_LIST = []
  def get_md5(data):
      obj = hashlib.md5('sadsa'.encode('utf-8'))
      obj.update(data.encode('utf-8'))
      result = obj.hexdigest()
      return result
  
  def register():
      print('请创建账户')
      while True:
          user = input("请输入用户名")
          if user == "N":
              return
          pwd = input("请输入密码")
          temp = {'username':user,'password':get_md5(pwd)}
          User_LIST.append(temp)
  
  def login():
      print("用户登录")
      user = input('请输入用户名')
      pwd = input('请输入密码')
  
      for item in User_LIST:
          if item["username"] == user and item['password'] == get_md5(pwd):
              return True
  
  register()
  result = login()
  if result:
      print("登录成功")
  else:
      print("登录失败")
  
  

• 密码不显示 — 只能在终端运行

  import getpass
  
  pwd = getpass.getpass("请输入密码：")
  if pwd == "123":
      print("输入正确")
  
  

2,装饰器

def base():
    print(1)

def bar():
    print(2)

bar = base
bar()

def func(arg):
    def inner():
        print(arg)
    return inner

v1 = func(1)
v2 = func(2)

2.2.1定义

def func(arg):
    def inner():
        return arg()
    return inner

def index():
    print('123')
    return  666

index = func(index)
index()



###示例一
v1 = index()  #执行 index函数，打印123并返回666赋值给v1


####示例二
v2 = func(index) #v2 是inner函数，arg = index函数
index = 666
v3 = v2()

####示例三
v4 = func(index)
index = v4  #index ==>inner
index()

5.2.2语法

def func(arg):
    def inner():
        print('before')
        v = arg()
        print('after')
        return v
    return inner

#第一步：执行func函数并将下面的函数参数传递，相当于：func(index)
#第二步：将func的返回值重新赋值给下面的函数名。index = func(index)
@func
def index():
    print('123')
    return  666

# print(index)
v = index()
print(v)

2.2.3应用

装饰器：在不改变原函数内部代码的基础上，在函数执行之前和之后自动执行某个功能

import time

'''
def func1():
    time.sleep(2)
    print(123)


def func2():
    time.sleep(2)
    print(123)


def func3():
    time.sleep(2)
    print(123)

start_time = time.time()    #获取当前时间
func1()
end_time = time.time()  #获取当前时间
print(end_time - start_time)

start_time = time.time()    #获取当前时间
func2()
end_time = time.time()  #获取当前时间
print(end_time - start_time)

start_time = time.time()    #获取当前时间
func3()
end_time = time.time()  #获取当前时间
print(end_time - start_time)
'''
'''
############## 场景一
def wraper(func):
    def inner():
        start_time = time.time()
        v = func()
        end_time = time.time()
        print(end_time - start_time)
        return v
    return inner
@wraper
def func1():
    time.sleep(2)
    print(123)

def func2():
    time.sleep(1)
    print(345)

func1()
func2()
'''


#######场景二
def add_user():
    #1,判断用户是否已经登录
    #2，已经登录可以继续
    pass

def del_user():
    # 1,判断用户是否已经登录
    # 2，已经登录可以继续
    pass

def update_user():
    # 1,判断用户是否已经登录
    # 2，已经登录可以继续
    pass

2.2.4总结

• 目的：在不改变原函数的基础上，在函数执行前后自定义功能

• 编写装饰器

  @x 作用

  #第一步：执行func函数并将下面的函数参数传递，相当于：func(index)
  #第二步：将func的返回值重新赋值给下面的函数名。index = func(index

  #装饰器的编写
  def x(func):
      def y():
          ret =func()
          return ret
      return y
  
  #装饰器的应用
  @x
  def index():
      pass
  
  @x
  def manager():
      pass
  
  #执行函数，自动触发装饰器
  v= index（）
  print(v)
  
  

• 应用场景

  想要为函数扩展功能时，可选择用装饰器

• 编写格式：

  def 外层函数(参数):
      def 内层函数(*args,**kwargs):
          return 参数(*args,**kwargs)
      return 内层函数		## 不能加
  
  

• 应用格式

  @外层函数
  def index():
      pass
  
  index()
  
  

2.2.5 带参数的装饰器

• 应用：：flask框架 + Django缓存+ 写装饰器实现被装饰的函数要执行N次

'''
def x(func):

    def inner (a1):
        return func(a1)
    return inner
@x
def index():
    pass

# index -> inner
# index(1)
'''

'''
def x(func):
    def inner (a1,a2):
        return func()
    return inner
@x
def index(a1,a2):
    pass
#func = 原来的index函数

# index -> inner
index(1,2)
'''

• 关于返回值

  #######关于返回值
  def x1(func):
      def inner(*args,**kwargs):
          data = func(*args,**kwargs)
          return 666
      return inner()
  
  @x1
  def f1():
      print(123)
      return 666
  v1 = f1()
  print(v1)
  
  

• 装饰器建议写法

  def x1(func):
      def inner(*args,**kwargs):
          data = func(*args,**kwargs)
          return data
      return inner()
  
  

2.2.6 带参数的装饰器 - 总结

#第一步：执行ret = xxx(index)
#第二步：将返回值赋值给index = ret
@xxx
def index():
    pass


#第一步：执行v1 = uuu(9)
#第二步：@v1 --> ret = v1(index)
#第三步：index = ret
@uuu(9)
def index():
    pass


#########普通装饰器
def wrapper(func):
    def inner(*args,**kwargs):
        data = func(*args,**kwargs)
        return data
    return inner()

@wrapper
def index():
    pass

#########带参数的装饰器
def x(counter):
    def wrapper(func):
        def inner(*args,**kwargs):
            data = func(*args,**kwargs)
            return data
        return inner()

@x(9)  #index = x(9)(index)  # <=> @wrapper
def index():
    pass

2.2.7 欠

• 元数据：flask框架

• 多个装饰器：flask框架

  @x1
  @x2
  def func():
      pass
  
  

3,推导式

• 列表推导式

  • 目的：方便的生成一个列表

  • 格式：

    v1 = [i for i in 可迭代对象]
    
    v2 = [i for i in 可迭代对象 if 条件]	#条件为true 才进行append
    
    

#########列表推导式

v1 = [ i for i in range(10)]


v2 = [ i+100 for i in range(10)]

v3 = [ 99 if i >5 else 66 for i in range(10)]
print(v3)

def func():
    pass
v4 = [ func for i in range(10)]

v5 = [ lambda :100 for i in range(10)]
result = v5[0]()

def func():
    return 1
v6 = [ func for i in range(10)]
result = v6[5]()

v7 = [ lambda :i for i in range(10)]
result = v7[5]()
'''
####面试题：
v8 = [ lambda x:x*i for i in range(10)]
#面试题：
#1，请问v8是什么
#2，请问v8[0](2)
result = v8[0](2)


def  num():
    return [lambda x:i*x for i in range(4)] #循环完，i=3
#num()  -> [函数，函数，函数，函数]
print([m(2) for  m in num()]) #[6,6,6,6]
'''

##########筛选#######
v9 = [i for i in range(10) if i > 5]

• 集合推导式

  v1 = { i for i in 'alex'}
  
  

• 字典推导式

  v1 = { 'k'+str(i) :i for i in range(10)}
  
  

4.sys模块

python 解释器相关的数据。

• sys.getrefcount – 获取一个值的应用计数

  #获取一个值的应用次数
  a = [11,22,33]
  b = a
  print(sys.getrefcount(a))
  
  

• sys.getrecursionlimit — python 默认支持的递归数量

• sys.stdout.out ---- print (进度)

• 示例：读文件进度

  import os
  import time
  
  #1，读取文件大小
  file_size = os.stat('001.Python介绍_特性_版本问题_应用范围.mp4').st_size
  print(file_size)
  
  #2, 一点一点的读取文件
  # chunk_size = 1024
  read_size = 0
  with open('001.Python介绍_特性_版本问题_应用范围.mp4',mode= 'rb') as f1,open('a.mp4',mode='wb') as f2:
      while read_size < file_size:
          chunk = f1.read(1024)   #每次最多去读取1024字节
          read_size += len(chunk)
          val = int(read_size / file_size * 100)
          print('%s%%\r'%val,end= '')
          # time.sleep(0.01)
  
  
  

• sys.argv ----- 重要

  """
  删除文件的脚本
  """
  import sys
  # print(sys.argv)
  #获取用户执行脚本时，传入的参数
  
  path = sys.argv[1]
  # print('删除',path)
  import shutil
  shutil.rmtree(path)
  
  

• sys.path

5,os 模块

和操作系统相关的数据

• os.path.exists(path) 如果path存在，返回True；如果pat不存在，返回False

• os.stat(‘001.Python介绍_特性_版本问题_应用范围.mp4’).st_size 获取文件大小

• os.path.abspath() #获取绝对路径

  path = '001.Python介绍_特性_版本问题_应用范围.mp4'
  
  import os
  v1 = os.path.abspath(path)
  print(v1)
  
  

• os.path.dirname 获取路径的上级目录

  import os
  v = r'E:\pycharm\Workplace\python_study\路飞学城\chapter5_模块\001.Python介绍_特性_版本问题_应用范围.mp4'
  
  print(os.path.dirname(v))
  
  

  r == 转义，

• os.path.join — 路径的拼接

  import os
  path = "D:\code\s21day14"
  v = "n.txt"
  result = os.path.join(path,v)
  print(result)
  
  

• os.listdir — 查看一个目录下的所有文件 【第一层】

  import os
  result = os.listdir(r'E:\pycharm\Workplace\python_study\路飞学城\chapter5_模块')
  for path in result:
      print(path)
  
  

• os.listdir — 查看一个目录下的所有文件 【第一层】

  import os
  result = os.walk(r'E:\pycharm\Workplace\python_study\路飞学城')
  for a,b,c in result:
      # print(a,b,c)
      #a,正在查看的目录；b，此目录下的文件夹；c，此目录下的文件
       for item in c:
           path = os.path.join(a,item)
           print(path)
  
  

6,shutil — 删除文件

import  shutil
# #删除目录
# shutil.rmtree('test')
#
# #重命名
# shutil.move('test','ttt')

#压缩文件
# shutil.make_archive('zzh', 'zip', 'E:\pycharm\Workplace\python_study\路飞学城\chapter5_模块\db')

#解压文件
shutil.unpack_archive('zzh.zip', format = 'zip')

• 练习题

  import  shutil
  import  os
  from datetime import datetime
  ctime = datetime.now().strftime('%Y-%m-%d-%H-%M-%S')
  print(ctime)
  if os.path.exists('code'):
      os.makedirs('code')
  
  #1,压缩lizhongwei文件夹zip
  shutil.make_archive(os.path.join('code',ctime),'zip','E:\pycharm\Workplace\python_study\路飞学城\chapter5_模块\lizhongwei')
  #2，放到code目录（默认不存在）
  #3，将文件解压到D:\x1目录中
  file_path = os.path.join('code',ctime)+'.zip'
  shutil.unpack_archive(file_path,r'D:\x1','zip')
  
  

7,time模块

import time
time.time()

​

8.内置模块

8.1,os

• os.mkdir 创建目录（x）

• os.makedirs 创建目录和子目录

  import os
  file_path = r'db\xx\xxx.txt'
  file_folder = os.path.dirname(file_path)
  if not  os.path.exists(file_folder):
      os.makedirs(file_folder)
  
  with open(file_path,mode='w',encoding='utf-8') as f:
      f.write('adsa')
  
  

• 重命名

  import os
  os.rename('db','sb')
  
  

• os.path.join

• os.path.dirname

• os.path.abspath

• os.path.exists

• os.stat(‘文件路径’)

• os.listdir

• os.walk

7.2sys

• sys.argv

• sys.path , 默认python去导入模块时，会按照sys.path 中的路径挨个查找

  import sys
  sys.path.append(r'D:')
  for path in sys.path:
      print(path)
  
  

• sys 是解释器相关的数据：递归次数、引用次数

8.json

json是一个特殊的字符串– 长得像列表、字典、字符串、数字、真假

• dumps
• loads

import json
#序列化，将python的值转换为json合适的字符串
# v = [12,3,4,{'k1':'v1'},True,'adas']
# v1 = json.dumps(v)
# print(v)

v2 = '["alex",123]'
print(type(v2))
v3 = json.loads(v2)	  ###反序列化
print(v3,type(v3))

8.1,json 和pickle

• json：优点：所有语言通用；缺点：只能序列化基本的数据类型 list、dict、int…

• pickle， 优点：python中所有的东西都可以被他序列化（socket对象）；缺点：序列化的内容只有python认识

  import pickle
  '''
  v = {1,2,3,4}
  val = pickle.dumps(v)
  print(val)
  
  data = pickle.loads(val)
  print(data,type(data))
  '''
  
  def f1 ():
      print('f1')
  
  v1 = pickle.dumps(f1)
  print(v1)
  v2 = pickle.loads(v1)
  print(v2)
  
  

9.datatime模块

9.1 获取时间

from datetime import datetime,timezone,timedelta
import time
#####获取datetime类型时间
# v1 = datetime.now() #当前本地时间
# print(v1)
#
# tz = timezone(timedelta(hours=7))   #当前东7区时间
# v2 = datetime.now(tz)
# print(v2)
#
# v3 = datetime.utcnow()  #当前utc时间
# print(v3)

############把datetime格式转换成字符串
# v1 = datetime.now()
# print(v1,type(v1))
# val= v1.strftime("%Y--%m==%d %H:%M:%S")
# print(val)

# #########字符串转成datetime#
# v1 =datetime.strptime('2011-11-11','%Y-%m-%d')
# print(v1,type(v1))
#
#
# #########datetime时间的加减#
# v1 = datetime.strptime('2011-11-11','%Y-%m-%d')
# v2 = v1 + timedelta(days= 140)
# print(v2)
# date = v2.strftime('%Y-%m-%d')
# print(date)


#########时间戳和datetime的关系#
# ctime = time.time()
# print(ctime)
# v1 = datetime.fromtimestamp(ctime)
# print(v1)

v1 = datetime.now()
val = v1.timestamp()
print(val)

9.2 关系

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-6879boMB-1572352415162)(C:\Users\Administrator\AppData\Roaming\Typora\typora-user-images\1572056701748.png)]

6.常见操作

1.第三方模块

• 下载、安装、使用

#把pip.exe 所在目录添加到环境变量中

pip install 要安装的模块名称  #pip install xlrd

2.自定义模块

• xxxx.py

  def f1():
      print('f1')
      
  def f2():
      print('f2')
  
  
  

• 使用自定义模块

  import xxxx
  xxxx.f1()
  
  

3.导入模块

• sys.path
• 导入
  • import
  • from xxx import xxxxx

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-lbHPuCUm-1572352415162)(C:\Users\Administrator\AppData\Roaming\Typora\typora-user-images\1571748978431.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-IvIoX1eT-1572352415164)(C:\Users\Administrator\AppData\Roaming\Typora\typora-user-images\1571749070131.png)]

7.异常处理

# try:
#     val = input('请输入数字')
#     num = int(val)
# except Exception as e:
#     print('操作异常')

练习题

#1,写函数，函数接受一个列表，将列表中元素每个都 + 100
def func(arg):
    result = []
    for item in arg:
        if item.isdecimal():
            result.append(int (item)+100)
    return result


#2,写函数，接受一个列表，列表中都是url，请访问每个地址并获取结果
import requests
def func1(url_list):
    result = []
    try:
        for url in url_list:
            response = response.get(url)
            result.append(response.text)
    except Exception as e:
        pass
    return result


def func2(url_list):
    result = []
    for url in url_list:
        try:
            response = response.get(url)
            result.append(response.text)
        except Exception as e:
                pass
    return result

func(['http://www.baidu.com','http://www.google.com','http://www.bing.com'])

8.迭代器+生成器

8.1 迭代器

• 任务：请展示列表中所有的数据

  • while + 索引 + 计数器

  • 迭代器，帮助你对某种对象(str/list/tuple/dict/set类创建的对象)中的元素进行逐一获取,

    表象：具有__next()__方法，且每次调用都获取可迭代对象中的元素(从前到后一个一个获取)

    • 列表转换成迭代器： v1 = iter([11,22,33,44])

    • 迭代器想要获取每个值：反复调用val = v1.__next__()

    • 直到报错：StopIteration错误，表示已经迭代完毕[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-olg4fcnd-1572352415166)(C:\Users\Administrator\AppData\Roaming\Typora\typora-user-images\1572078669142.png)]

      """
      v1 = iter([11,22,33,44])
      #列表转换成迭代器
      v2 = iter(v1)
      
      result1 = v2.__next__()
      print(result1)
      result2 = v2.__next__()
      print(result2)
      result3 = v2.__next__()
      print(result3)
      result4 = v2.__next__()
      print(result4)
      """
      
      v1 = iter([11,22,33,44])
      #v2 = iter(v1)
      v2 = v1.__iter__()
      while True:
          try:
              val = v2.__next__()
              print(val)
          except Exception as e:
              break
      
      
      

• 如何判别一个对象是否是迭代器：内部是否有__next__()

• for循环 使用迭代器原理

  v1 = [11,22,33,44]
  #1,内部会将v1转换成迭代器
  #2，内部反复执行 迭代器.__next()__
  #3,取完不报错
  for item in v1:
      print(item)
  
  

  [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-8ippbc7c-1572352415168)(C:\Users\Administrator\AppData\Roaming\Typora\typora-user-images\1572079494943.png)]

8.2 可迭代对象

• 具有__iter__()方法，且返回一个迭代器(***)

  v1 = [11,22,33,44]
  result = v1.__iter__()
  
  

• 能被for循环的对象

  for循环内部进行的操作

  #1,内部会将v1转换成迭代器# 
  #2，内部反复执行 迭代器.__next()__
  
  

8.3 生成器 (函数的变异)

# ###函数
# def func():
#     return 123
# func()

###生成器函数（内部是否包含yield）
def func():
    # arg =arg + 1
    print('f1')
    yield  1
    print('f2')
    yield  2
    print('f3')
    yield  100
    print('f111')

#函数内部代码不会执行，返回一个生成器对象

v1 = func()


# 生成器 是可以被for循环，一旦开始循环，那么函数内部代码就会开始执行
for item in v1:
    print(item)

练习题
def func():
    count = 1
    while True:
        yield count
        count += 1

val = func()

for item in val :
    print(item)

总结：函数中如果存在yield，那么该函数就是一个生成器函数，调用生成器函数会返回一个生成器，生成器只有被for循环时，生成器函数内部的代码才会执行，每次循环都会获取yield返回的值

9.面向对象

封装思想：将同一类的函数封装到一个类中。

9.1 面向对象

9.1.1 面向对象基本格式

#定义类
class 类名：
	def 方法名(self,name):
        print(name)
        return 123
#调用类中的方法
#1，创建该类的对象
obj = 类名()
#2,通过对象调用方法
result = obj.方法名('alex')
print(result)

• 应用场景：遇到很多函数，需要给函数做归类与划分【封装】

9.1.2 对象的作用

• 存储一些值，方便以后使用

class File:
    def read(self):
        print('打开文件并读取内容')
        with open(self.xxx,mode = 'r',encoding= 'utf-8') as f:
            data = f.read()
    def write(self,  conter):
        with open(self.xxx, mode ='a',encoding='utf-8') as f:
            f.write(conter)
        print('打开文件并写入内容')


#实例化了一个File类的对象
obj = File()
#在对象中写了一个xxx= 'test.log'

obj.xxx = "test.log"

#通过对象调用类中的read方法，read方法与self就是obj
obj.read()
obj.write('alex')

示例 - 初始化对象

class Person:
    def __init__(self,n,a,g):
        # print('zhixing init')
        self.name = n
        self.age = a
        self.gender = g

    def show(self):
        temp = "我是%s，年龄%s，性别%s"%(self.name,self.age,self.gender)
        print(temp)

p1 = Person('lishaoqi ',19,'nan')
p1.show()

p2 = Person('lishqo',12,'nv')
p2.show()

总结：将数据封装到对象，方便使用

示例：

# #1，循环让用户输入：用户名、密码、邮箱，输入完成后再进行数据打印
#
# #不使用面向对象
#
# USER_LIST = []
# while True:
#     user = input('请输入用户名：')
#     pwd = input('请输入密码：')
#     email = input('请输入邮箱：')
#     temp = {'username':user,'password':pwd,'email':email}
#     USER_LIST.append(temp)
#
# for item in USER_LIST:
#     temp = "我的名字：%s，密码：%s，邮箱：%s"%(item['username',item['password',item['email']]])
#     print(temp)



#面向对象写法
class Person:
    def __init__(self,user,pwd,email):
        self.username = user
        self.password = pwd
        self.email = email

    def info(self):
        return "我的名字：%s，密码：%s，邮箱：%s" % (item.username, item.password, item.email)


USER_LIST = []
while True:
    user = input('请输入用户名：')
    pwd = input('请输入密码：')
    email = input('请输入邮箱：')
    # temp = {'username':user,'password':pwd,'email':email}
    p = Person(user,pwd,email)

    USER_LIST.append(p)


for item in USER_LIST:
    msg = item.info()
    print(msg)

9.1.3 游戏开发示例

9.2 继承

#父类(基类）
class Base:
    def f1(self):
        pass

#子类（派生类）
class Foo(Base):
    def f2(self):
        pass

#创建一个子类的对象
obj =Foo()
#执行对象.方法时，优先在自己的类中找，如果没有就去父类中找
obj.f1()
obj.f2()

#创建了一个父类的对象
obj = Base()
obj.f1()

• 问题：什么时候使用继承？ - 多个类中如果有公共的方法，可以放到基类中，避免重复编写

  class Base:
      def f1(self):
          pass
  
  class Foo(Base):
      def f2(self):
          pass
  class Bar(Base):
      def f3(self):
          pass
  obj1 = Foo()
  obj2 = Bar()
  
  

• 继承关系中的查找方法的顺序

  • self 到底是谁？
  • self 是哪个类创建的，就从此类开始找，自己没有就找父类

  #示例一
  class Base:
      def f1(self):
          print('base.f1')
  class Foo(Base):
      def f2( )
  
  

9.3 多态