Python基础知识_学习笔记（20200629更新）

Python学习笔记

本人跟随pythonav武老师视频课学习

侵权删！

---

瞎哔哔区：

2020-04-19：跟随武老师视频整理了第一版笔记，计划每周末都将这一周的学习笔记整理出来，供大家分享讨论
2020-04-26：复工后的各种吐血忙碌和五一倒休，本想昨天周五更新来着，结果周五和周六都陪媳妇了，从下午两点逛到晚上九点。
注：房山篱笆房首创奥特莱斯疯狂打折，北面四件五折
2020-05-01：本次更新第五章 [函数] 和 [模块的引入] 五天小长假快乐，和女朋友回她家了，我老家牡丹江是彻底回不去了。
溜达吃玩一天，睡觉前整理的初稿，后续还会有补充。
2020-05-18：最近因为个人问题一直没更新，本周末学习完毕开始更新。
2020-05-26：我不要脸，我最近一直没学习。一直在忙私人问题
2020-05-27：模块部分小小补充
2020-06-14：微补充模块的调用。这几天面试保定的工作，好几年没面试了，第一面没准备好，好多想说的都没说出来，唉。
到时候看看面试结果吧，如果薪资不合适的话就继续在北京工作，每周末来回跑了。
2020-06-17：补充time/datetime/json模块。之前说的技术面试通过了，坐等HR谈薪资。
2020-06-29：添加推导式、装饰器，补充模块调用。保定工作凉凉，真是打脸啊，居然给我定薪六千，继续北京漂泊了。
2020-08-15：好久没更新了，因为在线视频课程基本没啥了，后续的都是花钱的了。最近学习状态也是不太好，需要调整调整。

---

---

第一章 计算机基础

1.1 硬件

计算机基本硬件由：cup / 内存 / 主板 / 硬盘 / 网卡 / 显卡 等组成，只有硬件无法进行交流和通信

1.2 操作系统

协调硬件之间相互工作，常见的操作系统

• Windows
• Linux
  • centos
• mac

1.3 解释器和编译器

编程语言的开发者写的一个工具，将用户写的代码转换成010101交给操作系统去执行。

1.3.1 解释型和编译型语言

解释型语言类似：实时翻译。代表：Python / PHP / Ruby /Perl

编译型语言类似于：说完之后，整体进行翻译。代表：C / C++ / Java / Go

1.4 软件（应用程序）

软件又称为应用程序，就是我们在电脑上使用的工具，类似于：快播 / 爱奇艺 / 熊猫浏览器 / 游戏

1.5 进制

对于计算机而言，无论是文件存储还是网络传输，本质上都是二进制（0101010101），比如，电脑上存储的图片或者文件，都是二进制；QQ微信上发送的表情和文字，本质上也都是二进制。

进制：

• 2进制：计算机内部。
• 8进制：
• 10进制：
• 16进制：一般用于表示二进制（用更短的内容更多的内容），一般是：\x开头

第二章 Python入门

2.1 环境的安装

• 解释器：py2 / py3 （环境变量）
• 开发工具：pycharm

2.2 编码

2.2.1编码基础

• ASCII
• Unicode
• utf - 8
• gbk
• gb2312

2.2.2python编码相关

对于python默认解释器编码：

py2：ASCII

py3：utf - 8

如果想要修改默认编码，则可以使用：

# -*- coding:gbk -*-

注意：对于操作文件时，要按照：以什么编码写入就用什么编码打开

2.3 变量

问：为什么要有变量？

为某个值创建一个“外号”，以后使用时直接可以使用外号直接调用。

2.3.1 变量规范

2.3.2 运算符

• 算数运算符，例如：加减乘除

  运算符	描述	实例
  +	加 - 两个对象相加	a + b 输出结果30
  -	减 - 得到负数或是一个数减去另一个数	a - b 输出结果-10
  *	乘 - 两个数相乘或是返回一个被重复若干次的字符串	a * b 输出结果200
  /	除 - x除以y	b / a 输出结果2
  %	取模 - 返回除法的余数	b % a 输出结果0
  **	幂 - 返回x的y次幂	a**b 为10的20次方
  //	取整除 - 返回商的整数部分	9//2 输出结果4

• 比较运算符，例如：大于、小于

  运算符	描述	实例
  ==	等于 - 比较两个对象是否相等	(a == b) 返回False
  !=	不等于- 比较两个对象是否不相等	(a != b) 返回True
  <>	不等于 - 比较两个对象是否不相等	(a <>b) 返回True。这个运算类似!=
  >	大于 - 返回x是否大于y	(a > b) 返回False
  <	小于 - 返回x是否小于y。所有比较运算符返回1表示真，返回0表示假。这分别与特殊的变量True和False等价。注意，这些变量名的大写	(a < b) 返回True
  >=	大于等于 - 返回x是否大于等于y	(a >= b) 返回False
  <=	小于等于 - 返回x是否小于等于y	(a <= b) 返回True

注意：python中不支持 <>

• 赋值运算，例如：变量赋值

  运算符	描述	实例
  =	简单的赋值运算符	c = a + b 的运算结果赋值为c
  +=	加法赋值运算符	c += a 等效于 c = c + a
  -+	减法赋值运算符	c -= a 等效于 c = c - a
  *=	乘法赋值运算符	c *= a 等效于 c = c * a
  /=	除法赋值运算符	c /= a 等效于 c = c / a
  %=	取模赋值运算符	c %= a 等效于 c = c % a
  **=	幂赋值运算符	c **= a 等效于 c = c ** a
  //=	取整除赋值运算符	c //= a 等效于 c = c // a

• 成员运算，例如：是否包含

  运算符	描述	实例
  in	如果在指定的序列中找到值返回True，否则返回False。	x在y序列中，如果x在y序列中返回True
  not in	如果在指定的序列中没有找到值返回True，否则返回False。	x不在y序列中，如果x不在y序列中返回True

• 逻辑运算，例如：且或非

  运算符	描述	实例
  and	布尔’与’ - 如果x为False，x and y 返回False，否则它返回y的计算值。	(a and b) 返回True
  or	布尔’或’ - 如果x是True，它返回True，否则它返回y的计算值。	(a or b) 返回True
  not	布尔’非’ - 如果x是True，返回False。如果x为False，它返回True	not (a and b) 返回False

2.3.2.1 逻辑运算

通常情况下逻辑运算一般都用在含有 条件判断 的位置，用于判断真假，例如：

# 示例1
if 1 == 1 and 2 > 3:
    print("真")
# 示例2
name = input("请输入用户名：")
if "wupeiqi" == name or 1 == 1:
    print("真")
# 示例3
flag = False
if not flag:
    print("来了老弟")
# 示例4
while 1 == 2 and 2 == 9:
    print("来了老妹")

示例一：

data = "alex"
# 如果第一个值转换为布尔值为True，则 name = 第一个值
# 如果第一个值转换为布尔值为False，则 name = 第二个值
name = data or "武沛齐"
print(name)
# 练习题
v1 = 1 or 2
v2 = -1 or 3
v3 = 0 or -1
v4 = 0 or 100
v5 = "" or 10
v6 = "wupeiqi" or ""
print(v1,v2,v3,v4,v5,v6)

示例二：

# 如果第一个值转换布尔值为True，则 num = 第二个值
num = 1 and 2
# 如果第一个值转换布尔值为False，则 num = 第一个值
num = 0 and 9

练习题：

# 练习题
v1 = 4 and 8
v2 = 0 and 6
v3 = -1 and 88
v4 = "" and 7
v5 = "武沛齐" and ""
v6 = "" and 0
v7 = 0 and "中国"
print(v1,v2,v3,v4,v5,v6,v7)

总结：

or， 看第一个值，如果是 `真` 则选择第一个值，否则选择第二个值。
and，看第一个值，如果是 `假` 则选择第一个值，否则选择第二个值。

示例三：

v1 = 1 and 6 or 8 and 0 or ""
# 结果：v1 = 6
# 流程分析：
#   第一步：处理 1 and 6，得到 v1 = 6 or 8 and 0 or ""
#   第二步：处理 8 and 0，得到 v1 = 6 or 0 or ""
#   第三步：处理 6 or 0 ，得到 v1 = 6 or ""
#   第四步：处理 6 or ""，得到 6

# 练习题
v1 = 0 or 4 and 3 or 7 or 9 and 6
v2 = 8 or 3 and 4 or 2 and 0 or 9 and 7
v3 = 0 or 2 and 3 and 4 or 6 and 0 or 3

2.3.2.2 运算优先级

关于所有的运算符都有一个优先级需要遵循，优先级从高到低依次是：

运算符	描述
**	指数（最高优先级）
~ + -	按位反转，一元加号和减号（最后两个的方法名为+@和-@）
* / % //	乘，除，取模和取整除
+ -	加法减法
>> <<	左移，右移运算符
&	位‘AND’
^ |	位运算符
<= < > >=	比较运算符
<> == !=	等于运算符
= %= /= //= -= += *= **=	赋值运算符
is is not	身份运算符
in not in	成员运算符
not and or	逻辑运算符

• 算数优先级优先级 大于 比较运算符

  if 2 + 10 > 11:
   print("真")
  else:
   print("假")
  

• 比较运算符优先级 大于 逻辑运算符

  if 1>2 and 2<10:
    print("成立")
  else:
    print("不成立")
  

• 逻辑运算符内部三个优先级 not > and > or

  if not 1 and 1>2 or 3 == 8:
    print("真")
  else:
    print("假")
  

  以上优先级从高到低总结：加减乘除 > 比较 > not and or

第三章 数据类型

3.1 整型（int）

3.1.1 整型的长度

py2中有：int / long

py3中有：int (int/long)

3.1.2 整除

py2：地板除，需引入模块

py3：有小数点

3.2 布尔（bool）

布尔值就是用于表示真假。True和False

其他类型转换成布尔值：

• str
• …

对于None / [] / {} / () 转换成布尔值都是False

3.3 字符串（str）

字符串是写代码中最常见的，python在内存中字符串是按Unicode编码存储，对于字符串是不可变的，如果变了需要新的内存地址接收。

字符串中有很多自己的方法，如：

1. 大写

   v = 'alex'
   v1 = v.upper()
   print(v1)
   v2 = v.isupper() #判断是否全部为大写
   print(v2)
   

2. 小写

   v = 'Alex'
   v1 = v.lower()
   print(v1)
   v2 = v.islower() #判断是否全部为小写
   print(v2)
   v3 = v.casefold() #更牛逼的变小写
   print(v3)
   

3. 判断是否是数字

   v = '1'
   v = '①'
   v = '一'
   v1 = v.isdigit() # '1'-> Trus;'一'->False;'①'->False
   v2 = v.isdecimal() #纯数字才可以
   v3 = v.isnumeric() #是数字的意思就可以 1/一/① 都行
   print(v1,v2,v3)
   

4. 去空白

   v1 = 'alex\n' #换行符
   print(v1.strip())
   
   v2 = 'alex\t' #制表符 Tab键
   print(v2.strip())
   
   v3 = '  alex   ' #去两边空格
   print(v3.strip())
   
   v4 = 'alexa'
   print(v4.strip('a')) #去两边的a
   

5. 替换

   .replace

6. 开头 / 结尾

7. 编码

   把字符串转换成二进制

8. 字符串格式化

   .format

9. 连接

   .join

10. 切割

    .split 一个字符串切割后是列表

    v = 'asidj3saji3dp'
    v1 = v.split('3') #分割后没有3
    print(v1)
    
    #找到第一个3，分成三份。前面的，他自己，后面的
    v = 'asidj3sajidp'
    v1 = v.partition('3') 
    print(v1)
    

11. 首字母大写

    .capitalize()

12. 居中

    v = 'alex'
    v1 = v.center(20,'*')
    print(v1)
    #结果：********alex********
    

13. 左/右补齐

    v = 'alex'
    v1 = v.ljust(20,'*')
    print(v1)
    #结果：****************alex
    
    v = 'alex'
    v1 = v.rjust(20,'*')
    print(v1)
    #结果：alex****************
    

14. 计算个数

    v = 'alex'
    v1 = v.count('a')
    print(v1)
    

15. 找

    find 从左到右找第一个出现的索引位置

    v = 'alex'
    index = v.find('e')
    print(index)
    #结果：2
    

    对比.index find找不到就会返回-1 index找不到报错

16. 字符串格式化

    format / format_map

    v = '我是{0},谢谢{1}'.format('alex',19)
    print(v)
    
    v = '我是{k1},谢谢{k2}'.format_map({'k1':'alex','k2':19})
    print(v)
    

17. 空白

    v = '  '
    v1 = v.isspace()
    print(v1)  #结果返回True
    

18. 大小写反转

    v = 'aleX'
    v1 = v.swapcase()
    print(v1)  #结果返回ALEx
    

19. 首字母大写

    v = 'aleX is sb'
    v1 = v.title()
    print(v1)  #结果:Alex Is Sb
    

20. 翻译

    a = '12345'
    b = 'abcde'
    table = str.maketrans(b,a)
    v = 'abaqwrpne'
    result = v.translate(table)
    print(result)
    #a改成1 b改成2 .... 即121qwrpn5
    

21. 其他…

3.4 列表

3.5 元组

3.6 字典

3.7 集合

3.8 公共功能

• len

  int 和 bool不具备

• 索引

  set不具备

• 切片

• 步长

• for循环

  除了int 和bool都可以

3.9 嵌套

第四章 文件操作

4.1 文件的基本操作

#打开文件 r-read只读;w-write只写;a-append只追加
# 文件不存在会报错
file_object = open('路径',mode='模式',encoding='编码')

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

#关闭文件
file_object.close()

4.2 打开模式

• r / w / a
• r+ / w+ / a+
• rb / wb / ab
• r+b / w+b / a+b

4.3 具体操作

• read() ：全部读到内存

• read(3)

  #按字符
  obj = open('a.txt',mode = r,encoding = 'utf-8') #文件内容：我是爸爸
  data = obj.read(1) #读一个字符
  obj.close()
  print(date) #结果：我
  
  #按字节
  obj = open('a.txt',mode = rb) #文件内容：我是爸爸
  data = obj.read(3) #读三个字节
  obj.close()
  print(date) #读三个字节，二进制的01010，16进制显示出
  print(data.decode('utf-8'))#二进制utf-8显示 ，我
  

• write()

也可以按字符和按字节

• seek(光标字节位置)，无论模式是否带b都是按照字节

• tell

  obj = open('a.txt',mode = r,encoding = 'utf-8') #文件内容：我是爸爸
  obj.seek(3)
  data = obj.tell() #获取光标当前所在的字节位置
  print(date)
  obj.close()
  #迅雷的断点续传，记录上次下载的字节位置，下次接着下
  

• flush

  obj = open('a.txt',mode = a,encoding = 'utf-8')
  while True:
      val = input('请输入')
      obj.write(vale)
  obj.close() #一直循环，没到关闭，写不进去
  
  obj = open('a.txt',mode = a,encoding = 'utf-8')
  while True:
      val = input('请输入')
      obj.write(vale)
      obj.flush #强制将内存内容刷进硬盘
  obj.close() 
  

4.4 关闭文件

• 每次手动关闭

  obj = open('a.txt',mode = r,encoding = 'utf-8') 
  obj.close()
  

• 自动关闭

  with open('a.txt',mode = r,encoding = 'utf-8') as obj
  	data = obj.read
      #缩进中的代码执行完后自动关闭
  

4.5 文件的修改

• 占用内存较小的文件修改

  with open('a.txt',mode = r,encoding = 'utf-8') as f1
  	data = f1.read
  new_data = data.replace('要替换','替换后内容')
  
  with open('a.txt',mode = r,encoding = 'utf-8') as f1
  	data = f1.wriet(new_data)
  

• 占用内存较大(利用seek)

  #方法1
  f1 = open('a.txt',mode = r,encoding = 'utf-8')
  f2 = open('b.txt',mode = r,encoding = 'utf-8')
  for line in f1:
      new_line = line.replace('要替换','替换后内容')
      f2.write(new_line)
  f1.close()
  f2.close()
  
  #方法二
  with open('a.txt',mode = r,encoding = 'utf-8') as f1, open('a.txt',mode = r,encoding = 'utf-8') as f2
  for line in f1:
      new_line = line.replace('要替换','替换后内容')
      f2.write(new_line)
  

第五章 函数

5.1三元运算

三元表达式又称之为三目运算符。python中没有其他语言中的三元表达式，不过有类似的方法。

首先我们先看看Java中的三元表达式。

int a = 1;
String b = "";
b =  a > 1? "执行表达式1":"执行表达式2"
System.out.println(b)

在python中只有类似的替代办法，如果条件为真，则返回前面的，否则返回后面的

a = 1
b = 2
h = a-b if a > b else b-a
#如果a大于b则a-b否则b-a

5.2 函数

截止目前：我们学到的都是面向过程的编程。

有两个缺点：可读性差 和 可重用性差 。于是引出了函数，函数可以理解类比变量，将某个或者某些东西赋值给一个值，将一些重复使用的过程变成函数，就使可读性和操作性大大提高。

例给不同的人发邮件：

user_input = input('请输入角色：')

if user_input == '管理员':
    pass #给管理员发邮件,10行代码
if user_input == '业务员':
    pass #给管理员发邮件,10行代码
if user_input == '老板':
    pass #给管理员发邮件,10行代码

如果将发邮件这一堆代码编程一个变量就简单了很多。

发送邮件：

def send_email():
    import smtplib
    from email.mime.text import MIMEText
    from emil.utils import formataddr

    msg = MIMEText('邮件内容','plain','utf-8')
    msg['From'] = formataddr(['姓名','邮箱地址'])
    msg['To'] = formataddr(['姓名','邮件地址'])
    msg['Subject'] = '主题'

    sever = smtplib.SMTP('smtp.126.com',25)
    sever.login('邮件地址','邮箱密码')
    sever.sendmail('上面的邮箱地址',['要发的对方邮箱地址', ], msg.as_string())
    sevet.quit()

对于函数编程：

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

5.2.1 函数的基本结构

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

# 函数的执行
函数名()

def get_list_first_data():
	v = [11,22,33,44]
	print(v[0])
	
get_list_first_data()
# 函数如果不被调用，则内部代码永远不会被执行

5.2.2 参数

def 函数名(参数): #此参数称为形式参数
   v = [11,22,33,44]
   print(v[0])
   
get_list_first_data(参数) #此参数称为实际参数

1. 基本参数知识

   • 任意个数
   • 任意类型

   def func(a1,a2,a3):
       print(a1,a2,a3)
   
   func(1,'asdf',True)
   

2. 位置传参（调用函数并传入参数）

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

3. 关键字传参[执行时候用]

   def func(a1,a2):
       print(a1,a2)
       
   func(a1=2,a2=3)
   
   #关键字传参和位置传参可以混合使用
   def func(a1,a2,a3):
       print(a1,a2,a3)
   
   func(1,2,a3=9) #位置参数一定要在前面
   

4. 默认参数[定义的时候用]

   def func(a1,a2=9):
       pass
   '''
   func函数接收两个函数，调用函数进行传值时候：
   	func(1,2)
       func(1,a2=10)
       func(123) 只传a1,a2就是默认的9
   '''
   

5. 万能参数（参数打散）

   • *args

     • 可以接受任意个数参数，并将参数转换成元组。

       • 调用可以不带星

         def func(*args):
             print(args)
         func(1,2,3,4)
         

       • 调用带星

         def func(*args):
             print(args)
         func(*(1,2,3,4,))
         func(*[1,2,3,4])
         

     • 只能用位置传参

   • **kwargs

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

       • 调用可以不带**

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

       • 调用可以带**

         def func(**kwargs):
             print(kwargs)
         func(**{'k1':'v1','k2':'v2'})
         

       • 只能用关键字传参

     • 综合应用

       def func(*args,**kwargs):
           print(args,kwargs)
       func(1,2,3,4,5,k1=2,k5=9)
       

   def func(*a1): #一般情况下，带星的都不写a1 都写args
       print(a1)
   
   *指的是万能的，可以接收多个参数
   func(1,2) #打印元组
   func((11,22,33,44,55)) #打印 元组套元组
   func(*(11,22,33,44,55)) #打印 相当于a1 = (11,22,33,44,55)
   

   def func(**v1):  #一般情况下，写kwargs
       print(v1)
       
   func(k1 = 1,k2 = 'alex') #打印 字典
   func(**{'k1':'v1','k2':'v2'}) #直接打印 字典
   

参数相关重点：

1. 定义函数

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

2. 位置参数 > 关键字参数

练习题

# 1、写一个函数，函数计算列表 info = [11,22,33,44,55]中所有元素的和
def get_sum():
    info = [11,22,33,44,55]
    num_sum = 0
    for num in info:
        num = int(num)
        num_sum += num
    print(num_sum)

get_sum()

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

get_list_sum([11,22,33])

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

join_list([11,22,33],[44,55,66])

# 4、计算一个列表的长度

v = [11,22,33]
len(v)

5.2.3 返回值

def func(arg):
	#.....
	return 1 #返回值为1 ,不写的话默认None
	
val = func('xxx') #接收到返回值

练习

# 1、让用户输入一段字符串，计算有多少大写A的字符的个数，将有多少个就在文件中a.txt中写多少个X
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(counter)
write_data = 'xxxx' * counter
staus = write_file(write_data)
if status:
    print('写入成功')
else:
    print('写入失败')

5.2.4 作用域

python中：

• py文件：全局作用域

• 局部作用域

  代码从上到下执行，只要全局前面有了，局部就能用。

• 总结

  • 一个函数是一个作用域

  • 作用域中查找数据的规则：优先在自己作用域中找，自己没有去上一级找

  • 子作用域只能找到父级中的值，默认无法重新为父级的变量重新赋值，如果非要给全局赋值，就要用global关键字。改变父级用nonlocal

    name = '武藤兰'
    def func():
        global name
        name = '苍井空'
    func()
    print(name) # 这时候武藤兰变成了苍井空
    

5.2.5 练习题

# 1、写函数，计算一个列表中有多少个数字，打印：列表中有%s个数字
# 	提示：type
def get_num_count(a1):
    count = 0
    for item in a1:
        if type(item) == int:
            count += 1
    msg = '列表中有%s个数字' % (count,)
    print(msg)

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

# 2、写函数，将列表中的偶数索引位置的数据构造成另外一个列表返回
#读题错误写的：
def data_list(a1):
    v1 = []
    counter = -1
    for item in a1:
        if type(item) == int and item % 2 == 0:
            counter += 1
            v1.append(counter)
        else:
            counter += 1
    print(v1)

data_list([2,'a',4])
#
def get_data_list(arg):
    v = arg[::2]
    return v

data = get_data_list([11,22,33,44,55,66])

# 3、读取文件，将文件的内容构造成指定格式的数据，并返回
"""
alex|123|18
eric|456|19
目标结构:
1、['alex|123|18','eric|456|19']
2、[['alex','123','18'],['eric','456',19]]
3、[
	{'name':'alex','pwd':'123','age':18},
	{'name':'eric','pwd':'456','age':19}
	]
"""

5.2.6 作业题

1. 写函数，检查获取传入列表或元组对象的所有奇数位索引对应的元素，并将其作为新列表返回。

2. 写函数，判断用户传入的一个对象（字符串或列表或元组任意）长度是否大于5，并返回真假。

3. 写函数，接受两个数字参数，返回比较大的那个数字。

4. 写函数，函数接收四个参数分别是：姓名，性别，年龄，学历。用户通过输入这四个内容，然后将这四个内容传入到函数，此函数接收到这四个内容，项内容根据’*'拼接起来并追加到一个student_msg文件中

5. 写函数，在函数内部生成如下规则的列表[1,1,2,3,5,8,13,21,34,55…]（斐波那契数列），并返回。注意：函数可接收一个参数用于指定列表中元素最大不可以超过的范围。

6. 写函数，验证用户名在文件data.txt中是否存在，如果存在则返回Ture，否则返回False。（函数有一个参数，用于接收用户输入的用户名）

7. 写函数，验证用户名在文件data.txt中是否存在，如果存在则返回True，否则返回False。（函数有一个参数，用于接收用户输入的用户名）

   data.txt文件格式如下：

   1|alex|123123

   2|eric|rwerwe

5.2 函数小高级

5.2.1 函数小高级

a = 123
name = '苍井空'
nums = [1,2,3,4]

def func():
    pass
# func = 函数

5.2.1.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:
    v = item()  #循环里执行函数
    print(v)

def func():
    print(123)

info = {'k1':func,'k2':func}
info['k1']() #去执行

混淆你的题

def func():
    print(123)
    
func_list1 = [func,func,func]
func_list2 = [func(),func(),func()] 

print(func_list1)  #没执行函数，返回的是函数的内存地址
print(func_list2)  #执行了函数，没有返回值，就是None

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

def func(arg):
    print(arg)
    
func(1)
func([1,2,3,4])

def show():
    return 999
func(show)  #函数show作为参数传入func，没有执行，传入的就是函数所在的内存地址

def func(arg):
    arg()
def show():
    print(666)
func(show)

面试题

def func1():
    print('x1')
def func2():
    print('x2')
def func3():
    print('x3') 
#用户输入f1 则运行函数func1 ；f2则运行func2；f3则运行func3

info = {
    'f1':func1,
    'f2':func2,
    'f3':func3
}

choice = input('请选择要选择的功能：')
function_name = info.get(choice)
if function_name:
    function_name()
else:
    print('输入错误')

5.2.2 lambda表达式

用于表示简单的函数

#三元运算，为了解决简单的if else的情况，如：
if 1==1:
    a = 123
else:
    a = 456
# 等价于 ↓ ：
a = 123 if 1==1 else 456


# lambda表达式，为了解决简单函数的情况，如：
def func(a1,a2):
    return a1 + a2
# 等价于 ↓ ：
func = lambda a1,a2: a1 + a2

#
func1 = lambda : 100
#
func2 = lambda x1: x1 * 10
#
func3 = lambda *args,**kwargs: len(args) + len(kwargs)
#
DATA = 10
func4 = lambda a1: a1 + DATA

# lambda表达式 + 三元运算 一行代码比较两数大小
func = lambda n1,n2: n1 if n1 > n2 else n2

练习题

#练习1
USER_LIST = []
func1 = lambda x: USER_LIST.append(x)

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

5.2.3 内置函数

• 自定义函数

• 内置函数

  • 其他

  • len

  • open

  • range

  • id

  • type

  • 输入输出

    • print
    • input

  • 强制转换

    • dict()
    • list()
    • tuple()
    • int()
    • str()
    • bool()
    • set()

  • 数学相关

    • abs

    • float

    • max

    • min

    • avg

    • divmod

      a,b = divmod(1001,5)
      print(a,b)
      

      USER_LIST = []
      for i in range(1,800):
      #请通过分页对数据进行展示
      '''
      要求：
      	每页显示10行
      	让用户输入要查看的页码
      '''
      USER_LIST = []
      for i in range(1,800):
          temp = i
          USER_LIST.append(temp)
          
      #数据总条数
      total_count = len(USER_LIST)
      #每页显示10条
      per_page_count = 10
      #总共需要多少个页码
      max_page_num,a = divmod(total_count,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:
          '''
          第一页：USER_LIST[0:10]
          第二页：USER_LIST[10:20]
          第三页：USER_LIST[20:30]
          ..........
          '''
          start = (pager - 1) * per_page_count
          end = pager * per_page_count
          data = USER_LIST[start:end]
          for item in data:
              print(item)
      

  • 进制转换相关

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

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

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

      num = 15
      v = oct(num)
      print(v)
      

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

      v1 = '0b1101' #进制标志 2:0b  8:0o  16:0x
      result = int(v1,base=2) #base参数代表进制
      print(result)
      

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

      num = 15
      v = hex(num)
      print(v)
      

    • 练习题

      #1字节等于8位
      #IP：1个字节.1个字节.1个字节.1个字节
      
      #请将IP中每个十进制数转换成二进制，并通过逗号连接起来，生成一个新的字符串
      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))
      

    • 面试题

      #请将IP中每个十进制数转换成二进制后拼接起来，转成十进制是多少
      ip = '192.168.12.79'
      ip_list = ip.split('.') #['192','168','12','79']
      result = []
      for item in ip_list:
          item0 = bin(int(item))
          item1 = item0.replace('0b','')
          item2 = item1.rjust(8,'0')
          result.append(item2)
      result1 = '0b' + ''.join(result)
      print(result1)
      result2 = int(result1,base=2)
      print(result2)
      

5.3 函数中高级

5.3.1 函数中高级

5.3.1.1 函数可以做返回值

def func():
    print(123)
    
def bar():
    return func

v= bar()
v()

name = '武藤兰'
def func():
    print(name)
    
def bar():
    return func

v= bar()
v()

def bar():
    def inner():
        print(123)
    return inner
v= bar()
v()

name = '加藤鹰'
def bar():
    name = '苍井空'
    def inner():
        print(123)
    return inner
v= bar()
v()

name = '加藤鹰'
def bar(name):
    def inner():
        print(123)
    return inner
v1 = bar('武藤兰') #{name=武藤兰, inner} #闭包，为函数创造一块区域（内部变量供自己使用），为他以后执行提供数据
v2 = bar('苍井空') #{name=苍井空, inner}
v1()
v2()

练习题

# 第一题
name = 'alex'
def base():
    print(name)
    
def func():
    name = 'eric'
    base()
func()

# 第二题
name = 'alex'
def func():
    name = 'eric'
    def base():
        print(name)
    base()
func()

# 第三题
def func():
    name = 'eric'
    def base():
        print(name)
    return base
base = func()
base()

注意：函数在何时被谁创建

面试题：

# 第一题
info = []

def func():
    print(item)
for item in range(10):
    info.append(func)
    
info[0]()

# 第二题
info = []
def func(i):
    def inner():
        print(i)
    return inner

for item in range(10):
    info.append(func(item))
    
info[0]()
info[1]()
info[4]()

5.3.1.2 闭包

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

v1 = func('alex')
v1()
v2 = func('eric')
v2()

5.3.1.3 高阶函数

• 对函数进行赋值
• 把函数当做参数传递
• 把函数当做返回值

5.3.1.4 总结

• 函数执行的流程分析（函数到底是谁创建的？画图理解）
• 闭包的概念：为函数创建一块区域保留并为其维护自己数据，以后执行时方便调用。
• 闭包的应用场景：装饰器，SQLAichemy源码

5.4 内置函数

• 编码相关

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

    v = chr(99)
    print(v)
    

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

    num = ord('中国')
    print(num)
    

  • 应用（随机验证码）

    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(起始,终止) # 得到一个范围内随机数
    

  • 高级一点的内置函数

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

      v1 = [11,22,33]
      # result = map(函数，可迭代对象) 循环对可迭代对象进行函数
      result = map(lambda x:x+100,v1) 
      print(result) #[111,122,133] py2直接展现列表
      print(list(result)) #py3特殊，对象object
      

    • filter ， 过滤

      v1 = [11,22,33,'小萝莉',44,'御姐']
      # result = filter(函数,可迭代对象)
      def func(x):
          if type(x) == int:
              return True
          return False
      result = filter(func,v1)
      print(list(result))
      
      # lambda表达式实现 方法一
      result = filter(lambda x:True if type(x) == int else False,v1)
      print(list(result))
      

    • 面试题：

      • 你常用的内置函数有哪些？

      • fillter/map/reduce是什么意思？

      • 什么是匿名函数？

        def func():
          pass
        
        lambda x:x+100
        

5.5 装饰器

5.5.1 基本格式

def x(func):
    def inner():
        return func()
    return inner

@x
def index():
    pass

# #######################
# 装饰器：在不改变原函数内部代码的基础上， 在函数执行之前和之后自动执行某个功能。
# 详细说明
def func(arg):
    def inner():
        print('before')
        v = arg()
        print('after')
        return v
    return inner

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

index = func(index)
index()
# 在不改变index函数内部的情况下，在前后加上before和after代码段

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'

5.5.2 关于参数

def x(func):
    def inner(*args,**kwargs):
        return func(*args,**kwargs)
    return inner

@x
def index(a1):
    pass

index()

5.5.3 关于返回值

# 案例1
def x(func):
    def inner(*args,**kwargs):
        data = func(*args,**kwargs)
        return data
    return inner

@x
def f1(a1):
    print(123)

v1 = f1()  # 返回None

# 案例2
def x(func):
    def inner(*args,**kwargs):
        data = func(*args,**kwargs)
        return data
    return inner

@x
def f1(a1):
    print(123)
    return 666

v1 = f1()  # 返回None

# 案例3
def x(func):
    def inner(*args,**kwargs):
        data = func(*args,**kwargs)
        return 666
    return inner

@x
def f1(a1):
    print(123)

v1 = f1()  # 返回666

5.5.4 关于前后

def x(func):
    def inner(*args,**kwargs):
        # 前
        data = func(*args,**kwargs) # 执行原函数
        # 后
        return data
    return inner

@x
def index(a1):
    print(123)
    
index()

练习题

# 让函数执行五次，每次结果追加到列表里
import random
def func():
    return random.randint(1,4)

# 答案
import random

def wrapper(func):
    def inner(*args,**kwargs):
        value = []
        for i in range(5):
            data = func(*args,**kwargs)
            value.append(data)
        return data
    return inner

@wrapper
def func():
    return random.randint(1,4)

5.5.5 带参数的装饰器

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


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

# ############ 普通修饰器 ############
def x(func):
    def inner(*args,**kwargs):
        # 前
        data = func(*args,**kwargs) # 执行原函数
        # 后
        return data
    return inner

@x
def index(a1):
    print(123)
   

# ############ 带参数修饰器 ############
def y(counter):
    def x(func):
        def inner(*args,**kwargs):
            # 前
            data = func(*args,**kwargs) # 执行原函数
            # 后
            return data
        return inner
    return x

@y(9) # 先执行y(9)函数，返回值是一个函数，传的参相当于个闭包
def index(a1):
    print(123)

练习题

# 写一个带参数的装饰器，实现：参数多少，被装饰的函数就执行多少次，把每次结果添加到列表中，返回列表

def y(counter):
    def x(func):
        def inner(*args,**kwargs):
            value = []
            for i in range(counter):
            data = func(*args,**kwargs) # 执行原函数
            value.append(data)
            return value
        return inner
    return x

@y(9)
def index():
    return 8
    
v = index()
print(v)

5.5.6 自己了解

• 元数据
• 多个装饰

5.5.7 应用

# 计算函数执行时间
import time

def wrapper(func):
    def inner():
        start_time = time.time()
        v = func()
        end_time = time.time()
        print(start_time - end_time)
        return v
    return inner

@wrapper
def func1():
    time.sleep(1)
    print(123)
    
func1()

5.5.8 总结

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

• 编写装饰器 和应用：

  # 编写
  def x(func):
      def y():
          ret = func()
          return ret
      return y
  # 应用
  @x
  def index():
      pass
  # 执行
  v = index()
  print(v)
  

• 应用场景：想要为函数扩展功能时，可以选择装饰器。

• 记住：

  • 装饰器编写格式

    def 外层函数(参数):
        def 内层函数(*args,**kwargs):
            return 参数(*args,**kwargs)
        return 内层函数
    

  • 装饰器应用格式

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

  • 为什么要加*args,**kwargs

5.6 推导式

5.6.1 列表推导式

• 基本格式

  '''
  目的：方便的生成一个列表
  格式：
  	v1 = [i for i in 可迭代对象 ]
  	v2 = [i for i in 可迭代对象 if 条件] # 条件为True才append
  '''
  变量 = [ for循环的变量 for循环一个可迭代对象 ]
  value = [ i for i in 'alex' ]
  # ['a','l','e','x']
  v2 = [i+100 for i in range(10)]
  v2 = [99 if i>5 else 66 for i in range(10)]
  
  def func():
      return 123
  v3 = [func for i in range(10)]
  
  v4 = [lambda :100 for i in range(10)]
  result = v4[0]()
  
  v5 = [lambda :100+i for i in range(10)]
  result = v5[0]()
  
  # 面试题一
  v6 = [lambda x:x*i for i in range(10)]
  result = v6[0]()
  # 1.请问 v6 是什么？
  # 2.请问 v6[0](2) 是什么？
  
  # 面试题二
  def num():
      return [lambda x:i*x for i in range(4)]
  print([ m(2) for m in num() ])
  
  # 筛选 先循环再判断再append
  v7 = [i for i in range(10) if i>5]
  

5.6.2 集合推导式

类比列表推导式即可

5.6.3 字典推导式

v1 = { 'k'+str(i):i for i in range(3) }
# v1 = {'k0':0,'k1':1,'k2':2}

第六章 模块

6.1 引入模块

将制定的‘字符串’进行加密

import hashlib

obj = hashlib.md5()
obj.update('要加密的字符串'.encode('utf-8')) #py3需要转码
result = obj.hexdigest()
print(result)

加盐

import hashlib

obj = hashlib.md5('dasdsada'.encode('utf-8')) #加盐，将这段字符串和要加密的字符串一起加密
obj.update('要加密的字符串'.encode('utf-8')) #py3需要转码
result = obj.hexdigest()
print(result)

案例

import hashlib
USER_LIST[]
def get_md5(data):
    obj = hashlib.md5('dasdsada'.encode('utf-8')) 
    obj.update('data'.encode('utf-8')) #py3需要转码
    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('请输入密码')
print(pwd)

6.2 模块的分类

6.2.1 内置模块

import sys
print(sys.argv)

• OS

  • os.path.join

  • os.mkdir ， 创建一级目录

  • os.makedirs ， 创建各级目录

    import os
    file_path = r'db\xx\xo\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 f1:
        f1.write('asdf')
    

  • os.path.dirname

  • os.path.abspath

  • os.path.exists

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

  • os.listdir

  • os.walk

  • os.rename(‘旧’,‘新’) ， 重命名

• SYS

  • sys.argv

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

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

    也可通过sys.path.append(‘路径’) 增加

• json

  dumps出来的是字符串

  优点：所有语言通用

  缺点：只能序列化基本的数据类型

  • 字典或列表中如果有中文，序列化想要保留中文显示

    v = {'k1':'alex','k2':'武藤兰'}
    
    import json
    val = json.dumps(v,ensure_ascii=False)
    print(val)
    

  • dumps

  • loads

• pickle

  dumps出来的是字节类型

  优点：：python中所有的东西都能被序列化，除socket对象

  缺点：序列化的内容只能被python用，其他语言不认识

• haslib

• random

• getpass

• shutil

  import shutil
  
  # 删除目录
  shutil.rmtree('目录')
  
  # 重命名
  shutil.move('文件名','文件名')
  shutil.move('目录名','目录名')
  
  # 压缩文件
  shutil.make_archive('压缩包名','zip','要压缩的目录')
  # 解压文件
  shutil.unpack_archive('文件名.后缀名',extract_dir='解压目标目录',format='zip')
  

• copy

• time

  from datetime import datetime
  ctime = datetime.now().strftime('%Y-%m-%d-%H-%M-%S')
  

  # 练习题
  
  # 1.压缩lizhongwei文件夹zip
  # 2.放到code目录（默认不存在的目录）
  # 3.将文件解压到D:\X1目录中
  import shutil
  import os
  from datetime import datetime
  ctime = datetime.now().strftime('%Y-%m-%d-%H-%M-%S')
  
  if os.path.exists('code'):
      os.makedirs('code')
  shutil.make_archive(os.path.join('code',ctime),'zip','路径')
  file_path = os.path.join('code',ctime) + '.zip'
  shutil.unpack_archive(file_path,r'D:\X1','zip')
  

• datetime

  import time
  from datetime import datetime,timezone,timedelta
  
  # 获取datetime格式的时间
  v1 = datatime.now() # 当前本地时间
  v2 = datatime.utcnow() # 格林尼治时间
  tz = timezone(timedelta(hours=7)) # 当前东7区时间
  
  # 将datetime格式时间转成字符串
  v1 = datatime.now()
  v1.strftime('%Y-%m-%d %H:%M:%S')
  
  # 将字符串转成datetime
  v1 = datetime.strptime('2020-01-01','%Y-%m-%d')
  print(v1)
  # 时间的加减
  v2 = v1 + timedelta(day=40) # 在v1时间基础上加40天
  v2 = v1 + timedelta(hours=20) # 在v1时间基础上加20小时
  
  # 时间戳和datetime
  ctime = time.time()
  v1 = datetime.fromtimestamp(ctime)
  print(v1) # datetime类型 2020-01-01 12:10:54.674727
  

6.2.2 第三方模块

找到Python安装目录中Scripts\pip.exe

通过他联网安装所需的第三方模块

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

pip install 要安装的模块名称

6.2.3 自定义模块

6.3 模块的定义

定义模块时，可以把一个.py文件或一个文件夹（包）当做一个模块，以方便于以后其他.py文件的调用创建文件夹时，在内创建一个_inti_.py文件（py2必须有，py3不用但建议也创建一个）

6.4 模块的调用

# 导入模块，加载此模块中所有的值（变量，函数）到内存
import 模块名

# 调用模块中的函数
模块名.函数名()

• import
  • import 模块1 模块1.函数()
  • import 模块1.模块2.模块3 模块1.模块2.模块3.函数()
• from xx import xxx
  • from 模块.模块 import 函数 函数()
  • from 模块.模块 import 函数 as f f()
  • from 模块.模块 import * 函数1() 函数2()
  • from 模块 import 模块 模块.函数()
  • from 模块 import 模块 as m m.函数()

6.5总结

• 自定义函数

  • 基本函数结构
  • 高级
    • 参数
    • 闭包

• 内置函数

  常用的内置模块：json / time / os / sys

• 模块

  • random
  • hashlib
  • getpass

第七章 面向对象

第八章 网络编程

第九章 并发编程

第十章 数据库

第十一章 前端开发

第十二章 Django框架

附录 单词和常见错误

• 单词

单词	作用	使用方法
data.replace(a,b,c)	替换	将data中的a替换成b，c代表替换次数，默认不填代表全部替换
data.split(a,b)	分割	以a分割data，结果中不显示a，b代表分割次数，默认不填代表全部分割。data中不存在a不会报错

• 报错信息

报错信息	问题定位	解决方案
IndentationError: unindent does not match any outer indentation level	占位问题，存在两种可能性：1.代码没有对齐 2.存在非法字符与其他格式的不可见的内容（输入法的问题）	1.TAB对齐代码 2.选择代码，缩进-删除（or插入）制表符
SyntaxError: invalid character in identifier

练习题

一、数据类型（一）

1. 有变量name = “aleX leNb “ 完成如下操作：

   • 移除 name 变量对应的值两边的空格,并输出处理结果

     name = 'aleX leNb 
     name_new = name.strip()
     print(name_new)
     

   • 判断 name 变量是否以 “al” 开头,并输出结果（用切片）

     name = 'aleX leNb '
     name_new = name[:2]
     if name_new == 'al':
     	print('是')
     print('否')
     

   • 判断name变量是否以”Nb”结尾,并输出结果（用切片）

     name = 'aleX leNb '
     name_len = len(name)
     len_int = int(name_len)
     name_new = name[len_int-2:len_int]
     if name_new == 'Nb':
         print('是')
     print('否')
     

   • 将 name 变量对应的值中的 所有的”l” 替换为 “p”,并输出结果

     name = 'aleX leNb '
     name_new = name.replace('l','P')
     print(name_new)
     

   • 将name变量对应的值中的第一个”l”替换成”p”,并输出结果

     name = 'aleX leNb '
     name_new = name.replace('l','P',1) #第三个参数是代表替换的次数，不填默认全部替换
     print(name_new)
     

   • 将 name 变量对应的值根据 所有的”l” 分割,并输出结果

     name = 'aleX leNb '
     name_new = name.split('l')
     print(name_new)
     

   • 将name变量对应的值根据第一个”l”分割,并输出结果

     name = 'aleX leNb '
     name_new = name.split('l',1)#第三个参数是代表分割的次数，不填默认全部分割
     print(name_new)
     

   • 将 name 变量对应的值变大写,并输出结果

     name = 'aleX leNb '
     name_new = name.upper()
     print(name_new)
     

   • 将 name 变量对应的值变小写,并输出结果

     name = 'aleX leNb '
     name_new = name.lower()
     print(name_new)
     

   • 请输出 name 变量对应的值的第 2 个字符?

     name = 'aleX leNb '
     name_new = name[1:2]
     print(name_new)
     

   • 请输出 name 变量对应的值的前 3 个字符?

     name = 'aleX leNb '
     name_new = name[:3]
     print(name_new)
     

   • 请输出 name 变量对应的值的后 2 个字符?

     name = 'aleX leNb '
     name_len = len(name)
     name_len_int = int(name_len)
     name_new = name[name_len_int-2:name_len_int]
     print(name_new)
     

2. 有字符串s = “123a4b5c”

   • 通过对s切片形成新的字符串 “123”
   • 通过对s切片形成新的字符串 “a4b”
   • 通过对s切片形成字符串s5,s5 = “c”
   • 通过对s切片形成字符串s6,s6 = “ba2”

3. 使用while和for循环字符串 s=”asdfer” 中每个元素。

   s='asdfer'
   for item in s:
       print(item)
   

4. 使用while和for循环对s=”321”进行循环，打印的内容依次是：”倒计时3秒”，”倒计时2秒”，”倒计时1秒”，”出发！”。

   s = '321'
   for num in s:
       item = '倒计时{0}秒'.format(num)
       print(item)
   

5. 使用while和for循环分别对字符串 message = “伤情最是晚凉天，憔悴厮人不堪言。” 进行打印。

6. 获取用户输入的内容，并计算前四位”l”出现几次,并输出结果。

   data = input('请输入内容:')
   data_f = data[:4]
   l_count = data_f.count('l')
   print(l_count)
   

7. 获取用户两次输入的内容，并将所有的数据获取并进行相加，如：

   """
    要求：
        将num1中的的所有数字找到并拼接起来：1232312
        将num1中的的所有数字找到并拼接起来：1218323
        然后将两个数字进行相加。
    """
    num1 = input("请输入：") # asdfd123sf2312
    num2 = input("请输入：") # a12dfd183sf23
    # 请补充代码
   num_sum = 0
   num1_str = ''
   num1 = input("请输入：")  # 输入asd123,想打印出6
   for n1 in num1:
       n1_flag = n1.isdecimal()
       if n1_flag:
           num1_str = num1_str.join(n1)
           print(num1_str,end='')
           n1 = int(n1)
           num_sum += n1
   
   num2_str = ''
   num2 = input("\n请输入：")  # 输入asd123,想打印出6
   for n2 in num2:
       n2_flag = n2.isdecimal()
       if n2_flag:
           num2_str = num2_str.join(n2)
           print(num2_str,end='')
           n2 = int(n2)
           num_sum += n2
   print('\n')#少个换行再输出num_sum,就拿着个用了
   print(num_sum)
   

二、数据类型（二）

1. 利用for循环和range打印出下面列表的索引。

   li = [“alex”, “WuSir”, “ritian”, “barry”, “wenzhou”]

   li = ['alex','WuSir','ritian','barry','wenzhou']
   for i in li:
   	print(i)
   

2. 利用for循环和range找出100以内所有的偶数并将这些偶数插入到一个新列表中

   list = []
   for i in range(0,101):
       i = int(i)
       if i % 2 == 0:
           list.append(i)
   print(list)
   

3. 利用for循环和range 找出50以内能被3整除的数，并将这些数插入到一个新列表中

   list = []
   for i in range(0,51):
       i = int(i)
       if i % 3 == 0:
           list.append(i)
   print(list)
   

4. 利用for循环和range从100~1，倒序打印

   list = []
   for i in range(0,101):
       list.append(i)
   print(list[::-1])
   

5. 利用for循环和range循环1-30的数字，将能被3整除的添加到一个列表中，将能被4整除的添加到另外一个列表中。