Python基础学习笔记(每日持续更新)

第一章 计算机基础

1.1 硬件

计算机基本的硬件由：CPU / 内存 / 主板 / 硬盘 / 网卡 / 显卡 等组成，只有硬件但硬件之间无法进行交流和通信。需要操作系统进行协调工作

1.2 操作系统

操作系统用于协同或控制硬件之间进行工作，常见的操作系统有那些:

• windows,个人办公系统,图形窗口
• linux
  • centos 【公司线上一般用】
  • redhat 收费
  • unbutu 图形界面较好
• mac,个人开发使用,人机交互较好

1.3 解释器或编译器

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

1.3.1 解释和编译型语言

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

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

1.4 软件（应用程序）

软件又称为应用程序，就是我们在电脑上使用的工具，类似于：记事本 / 图片查看 / 游戏

1.5 进制

对于计算机而言无论是文件存储 / 网络传输输入本质上都是：二进制（010101010101），如：电脑上存储视频/图片/文件都是二进制； QQ/微信聊天发送的表情/文字/语言/视频 也全部都是二进制。

进制：

• 2进制，计算机内部。
• 8进制
• 10进制，人来进行使用一般情况下计算机可以获取10进制，然后再内部会自动转换成二进制并操作。
• 16进制，一般用于表示二进制（用更短的内容表示更多的数据）。

第二章 Python入门

2.1 环境的安装

• 解释器：py2 / py3 （环境变量）
• 环境安装参见https://blog.csdn.net/ling_mochen/article/details/79314118
• 开发工具：pycharm

2.2 编码

2.2.1 编码基础

• ascii:只针对英语编码,8位表示一个东西,共有2**8个,unicode 分为 ecs2 (2字节) 和 ecs4 (4字节).
• unicode:万国码,32位表示一个东西,共有2**32个;
• utf-8:给unicode压缩优化,用尽量少的位数表示一个东西;(8意思是8的倍数),3个字节表示中文.
• gbk:两个字节表示中文.
• gb2312

2.2.2 python编码相关

输入

• py2: num = raw_input(“提示输入内容”)
• py3 : num= input(“提示输入内容”)

输出

• py2: print “小钻风”
• py3: print(“小钻风”)

对于Python默认解释器编码：

• py2： 默认解释器编码ascii
• py3： 默认解释器编码utf-8

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

# -*- coding:utf-8 -*- 

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

2.3 变量

问：为什么要有变量？

为某个值创建一个“外号”，以后在使用时候通过此外号就可以直接调用。

• 变量要求

1. 变量只能由数字,字母和下划线组成
2. 数字不能开头,不能纯数字
3. 不能包含python关键字
4. 见名知意
5. 命名方法下划线命名,例:big_ox

2.4 if条件判断

基本结构

if 条件 :
	结果
else:
	结果

2.5while循环

1. while循环基本结构;

   while 条件:   
       结果
       # 如果条件为真，那么循环则执行
       # 如果条件为假，那么循环不执行
   

2. debug模式显示每一步运行结果;

3. 关键字

• break ** #终止当前**循环;
• **continue **(继续) #如果碰到continue,则退出当前循环,立即回到while条件位置.

4. while else #while条件不再满足时执行else.

2.6for循环

(公共功能)

• for循环基本结构

  for 新变量 in 原变量:

  ​ 结果 ----------------循环取出原变量的字符赋值给新变量

name = 'bigox'
for new_name in name:
    print(new_name)

• for循环中break和continue用法一样
• 在使用循环中,有穷尽的优先考虑for循环,无穷尽的考虑while循环

range界限

#  range(1,5,1)    #第一个参数是范围的起始位置,第二个参数是范围的结束位置,第三个为步长,默认为1,取值顾首不顾尾.
for num in range(1,9):
	print(num)          #=======>输出为1-8

2.7运算符(特殊)

1. 算数运算

   • %取余
   • **幂
   • //整除

2. 比较运算

   • ==比较对象是否相等
   • !=不等于

3. 赋值运算

   • += 加法赋值: c+=a <==> c =c+a

4. 逻辑运算

   • bool类型数字0和空字符串’'是False,其余是True.

   1. and "与"

      v  = 1 and 9   =====>  v = 9   #如果第一个值转换为布尔值时如果为True,则v=第二个值;
      v1 = 0 and 1   =====>  v = 0   #如果第一个值转换为布尔值时如果为False,则v=第一个值;
      v1 = 0 and ''  =====>  v = 0   #如果有多个and,从左到右进行判断.
      

   2. or "或"

      v  = 1 or 9   =====>  v = 1    #如果第一个值转换为布尔值时如果为True,则v=第一个值;
      v1 = 0 or 1   =====>  v = 1    #如果第一个值转换为布尔值时如果为False,则v=第二个值;
      v1 = 0 or ''  =====>  v = ''   #如果有多个or,从左到右进行判断.
      

   3. not "非"

   • 在没有()的情况下,not优先级大于and,and优先级大于or,即 () >not >and > or.同一优先级从左往右计算.
   • 先进行数学运算,在进行逻辑运算

   补充:

   in / not in

   #示例:(是否包含敏感字符)
   while True:
       text = input('请输入你要说的话:')
       if '傻逼'in text:
           print('包涵敏感字符')
   

第三章 数据类型

3.1 整型（int）

3.1.1 整型的长度

py2中有：int/long

py3中有：int （int/long）

3.1.2 整除

py2和py3中整除是不一样。

py2除法只能取整数,py3除法取全部值

py2除法取全部值,需要加代码:
from future improt division
value = 3/2
print(value)

3.2 布尔（bool）

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

其他类型转换成布尔值：

• str()
• …

对于：None / “” / 0 … -> false

3.3 字符串（str）

3.3.1字符串格式化:

字符串是写代码中最常见的，python内存中的字符串是按照：unicode 编码存储。对于字符串是不可变。

1. \n换行符

2. 基本格式

   name = input('请输入姓名:')
   age = input('请输入年龄:')
   job = input('请输入工作:')
   hobby = input('请输入爱好:')
   msg = '''
   ---------- info of bigox ----------
   Name	:%s
   Age		:%s
   Job		:%s
   Hobby	:%s
   ------------- end -------------'''
   print(msg%(小钻风,500,it,girl,))
   
   

3. • %s 表示字符串;
   • %d 表示数字;
   • %% 字符串格式化时表示百分数.

注意要点:

1.input 输入内容全是字符串.

2.py版本输入格式区别

• py2: name = raw_input(‘请输入姓名’)
• py3: name = input(‘请输入姓名’)

3.3.2字符操作方法

字符串 str:upper/lower/isdecimal/strip/replace/split/startswith/endswith/format/encode/join

1. 大写： upper

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

2. 小写：lower

   v = 'alex'
   v1 = v.lower()
   print(v1)
   v2 = v.islower() # 判断是否全部是小写
   print(v2)
   
   ############ 了解即可
   v = 'ß'
   # 将字符串变小写（更牛逼）
   v1 = v.casefold()
   print(v1) # ss
   v2 = v.lower()
   print(v2)
   

3. 判断是否是数字： isdecimal

   v = '1'
   # v = '二'
   # v = '②'
   v1 = v.isdigit()  # '1'-> True; '二'-> False; '②' --> True
   v2 = v.isdecimal() # '1'-> True; '二'-> False; '②' --> False
   v3 = v.isnumeric() # '1'-> True; '二'-> True; '②' --> True
   print(v1,v2,v3)
   # 推荐用 isdecimal 判断是否是 10进制的数。
   
   # ############## 应用 ##############
   v = ['alex','eric','tony']
   for i in v:
       print(i)
   num = input('请输入序号：')
   if num.isdecimal():
       num = int(num)
       print(v[num])
   else:
       print('你输入的不是数字')
   
   

4. 去空白+\t+\n + 指定字符串.strip()

   v1 = "alex "
   print(v1.strip())
   
   v2 = "alex\t"
   print(v2.strip())
   
   v3 = "alex\n"
   print(v3.strip())
   
   v1 = "alexa"
   print(v1.strip('al'))
   
   

5. 替换 replace

   #.replace()
   message = input('请输入"大傻逼"')
   new_mes = message.replace('傻逼','**')
   print(new_mes)
   #.replace('原字符','替换字符','替换个数')
   
   

6. .startswith() 判断是否以()开头,输出值为bool类型

   name = 'bigox'
   print(name.startswith('big'))
   
   

7. .endswith() 同.startswith()用法相同

8. .format()格式(同字符串格式化)

name = '我叫:{0},年龄:{1}'.format('bigox',24)
print(name)

9. .encode() :编码转换

name  = '刘'              #解释器读取到内存后,按照unicode编码存储:8字节.

print(name.encode('utf-8'))    #转化为utf-8编码

​ 10 .join()循环每个元素,并在元素之间加入连接符.

name = 'bigox'
new_name = '_'.join(name)
print(new_name)       #输出结果为  b_i_g_o_x

11. 分割:字符串切割后形成列表

    #.split()
    name = 'abcdefg'
    new_name = name.split('d')
    print(new_name)
    #.split('分割点',分割次数)
    
    

    • 分割时引用字母或数字分割时该字母数字消失,如果是标点符号,则不消失.

3.4 列表list

列表独有方法

1. ** .append()列表最后追加元素**

   lst = ["麻花藤", "林俊杰", "周润发", "周芷若"] 
   print(lst) 
   lst.append("wusir") 
   print(lst)
   
   

2. .insert在指定的索引位置插入元素

   lst = ["麻花藤", "林俊杰", "周润发", "周芷若"] 
   print(lst) 
   lst.insert(1,"wusir") 
   print(lst)
   
   

3. **.remove()**指定元素删除

   .remove(“指定元素”)

4. **.pop()**删除索引元素:()如果没有索引值的话默认删除出最后一个

   .pop(索引)

5. **.clear()**清空

6. del[ ]切片删除

7. .extend()添加

   li = ["alex", "WuSir", "ritian", "barry", "wenzhou"]
   s = 'qwert'
   li.extend(s)
   print(li)
   #---------------------------
   lst = ["王志文", "张一山", "苦海无涯"]
   lst.extend(["麻花藤", "麻花不疼"])
   print(lst)
   
   

8. reverse反转

v = [1,2,3,4,5,6]
v.reverse()
print() #[6, 5, 4, 3, 2, 1]

9. sort排序

v = [1,3,7,4,5,6]
v.sort()
print() 	#[1, 3, 4, 5, 6, 7]
#v.sort()	从小到大排序(默认)
#v.sort(reverse=True)  从大到小排序

• 列表转字符串:

  nums = [11,22,33,44]
  for a in range(0,len(nums)):
      nums[a] = str(nums[a]) 
  result = ''.join(nums)
  print(result)
  
  

  3.5元组tuple

• 元组为不可变类型

• 元组子元素不可变,而子元素内部的子元素是可以变的,取决于元素是否为可变对象

• 元组中如果只有一个元素,一定要添加一个逗号,否者不是元组(1,)

• 可嵌套

3.5字典dict

• 字典:帮助用户表示事物的信息(事物有多个属性)

• 基本格式:字典键的数据类型不能为list和tuple,值可以为任何类型.

  dictionary = {'键':'值','键':'值','键':'值'}
  
  

独有功能:

info = {"name":'刘伟达','age':18,'gender':'男','hobby':'同桌'}

• 获取字典info所有键.keys()

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

• 获取字典info所有值.values()

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

• 获取字典info所有的键值对.items()

  for i in info.items():
  	print(i)
  

• .get()取值

  info = {'k1':'v1','k2':'v2'}
  a = info.get('k1')
  print(a)	#v1
  info2 = ['11111']
  b = info.get('11111',22222)
  print(b)	#22222
  

• .update()更新,存在就更改,不存在增加

  info = {'k1':'v1','k2':'v2'}
  info.update({'k1':'v0','k3':'v3'})
  print(info)	#{'k1': 'v0', 'k2': 'v2', 'k3': 'v3'}
  

****判断是否存在敏感字符

• in/not in 是否包涵(输出类型为bool类型)

  str/list/tuple/dict都适用

  # # 经典例题 # #
  # 让用户输入任意字符串，然后判断此字符串是否包含指定的敏感字符。
  
  #char_list = ['利奇航','堂有光','炸展会']
  #content = input('请输入内容：') # 我叫利奇航  / 我是堂有光  / 我要炸展会
  
  char_list = ['利奇航','堂有光','炸展会']
  i = True
  content = input('请输入内容:')
  for mes in char_list:
      if mes in content:
      	i = False
         	break
  if i:
      print(无敏感字符)
  else:
      print(包含敏感字符)
      
  
  

3.6集合set

• 在集合中True与数字1重复,False与数字0重复
• 列表, 字典和集合为可更改类型,不可哈希,不能存放在集合当中.

集合独有功能,

• .add() 添加

• .discard()删除

• 要修改,需要先删除再添加

• .clear()清空

• .update()

  info = {'k1','k2'}
  info.update({'k1','k3','v3'})
  print(info)	#{'k1','k2','k3','v3'}
  
  

• .intersection() 交集

  ​ 命令后的 () 可以是集合,也可以是列表.

  info = {1,2,3}
  print(info.intersection({1,3,4}))	#{1,3}
  
  

• .union()并集

  info = {1,2,3}
  print(info.union({1,3,4}))	#{1,2,3,4}
  
  

• .difference()差集

  info = {1,2,3}
  print(info.union({1,3,4}))	#{2,4}
  
  

3.7 公共功能

• len
• 索引
• 切片
• 步长
• for循环
• 列表, 字典和集合为可更改类型,不可哈希,不能存放在集合当中.也不能作为字典的键.

3.8内存相关

• id(查看内存地址)

• 赋值更改内存地址,内部变更改变量的值

• 内存地址

  a = 1
  b = 1
  id(a) = id(b)
  #按理说a与b的id不该一样,但是在python中,为了提高运算性能,对某些特殊情况进行了缓存.(小数据池)缓存对象:
  1. 整型：  -5 ~ 256 
  2. 字符串："alex",'asfasd asdf asdf d_asdf '       ----"f_*" * 3  - 重新开辟内存。
  
  

• == 与is 区别

  • ==比较的是值是否一致
  • is 比较内存地址是否一致

• 对str,int,bool,tuple不可变数据类型深浅拷贝都一样,对于list,dict,set可变数据类型才有区别

  ############## 示例 ############
  v1 = 'alex'
  import copy                    #固定格式
  v2 = copy.copy(v1)
  print(id(v1),id(v2))
  
  

• 浅拷贝 copy.copay()

  • 拷贝第一层.

• 深拷贝 copy.deepcopy()

  • 拷贝嵌套层次中的所有可变类型

3.9各数据类型常用操作总结

一.数字/整型int

• int()强行转化数字

二.bool类型False&True

• bool()强行转化布尔类型.
• 0,None,及各个空的字符类型为False.其余均为Ture.

三.字符串str

• str()强行转化字符串

  #列表转化字符换
  nums = [11,22,33,44]
  for a in range(0,len(nums)):
      nums[a] = str(nums[a]) 
  result = ''.join(nums)
  print(result)
  
  

• .upper()转化大写

  name = 'abc'
  new_name = name.upper()
  print(new_name)  
  
  

• .lower()转化小写

  name = 'ABC'
  new_name = name.lower()
  print(new_name)
  
  

• .replace()替换

  message = input('请输入"大傻逼"')
  new_mes = message.replace('傻逼','**')
  print(new_mes)
  #.replace('原字符','替换字符','替换个数')
  
  

• .strip()去首尾空格

  name = ' abc '
  new_name = name.strip()
  print(new_name)
  #.rstrip()去除右侧空格   .lstrip()去除左侧空格
  
  

• .split()分割

  name = 'abcdefg'
  new_name = name.split('d')
  print(new_name)
  #.split('分割点',分割次数)
  
  

• .isdecimal()判断是否可以转化位数字

  while True:
      num = input('请输入内容:')      
      num1= num.isdigit()             #print(num1) 数字的话输出True,非数字输出FALSE            
      if num1:
          print('你输入正确')
          break
      else:
          print('请输入数字')
  
  

• .startswith() 判断是否以()开头,输出值为bool类型

  name = 'bigox'
  print(name.startswith('big'))
  
  

• endswith() 判断是否以()结尾,输出值为bool类型 同.startswith()用法相同

• .format()格式(同字符串格式化)

  name = '我叫:{0},年龄:{1}'.format('bigox',24)
  print(name)
  
  
  

• .encode() :编码转换

  name  = '刘'              #解释器读取到内存后,按照unicode编码存储:8字节.
  print(name.encode('utf-8'))    #转化为utf-8编码
  
  
  

• .join()循环每个元素,并在元素之间加入连接符.

  name = 'bigox'
  new_name = '_'.join(name)
  print(new_name)       #输出结果为  b_i_g_o_x
  
  
  

四.列表list

• 列表转换list()

  #列表转化字符换
  nums = [11,22,33,44]
  for a in range(0,len(nums)):
      nums[a] = str(nums[a]) 
  result = ''.join(nums)
  print(result)
  
  
  

• .pop(索引)

  a = li.pop(2) #在列表中删除,并将删除的此数据赋值给a

  name = ['bigox','xo','ox']
  name.pop(1)
  print(name)
  
  
  

• del 列表 [索引]

  name = ['bigox','xo','ox']
  del name[0:2]
  print(name)
  
  
  

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

  lst = ["麻花藤", "林俊杰", "周润发", "周芷若"] 
  print(lst) 
  lst.append("wusir") 
  print(lst)
  
  
  

• .insert()在指定的索引位置插入元素

  lst = ["麻花藤", "林俊杰", "周润发", "周芷若"] 
  print(lst) 
  lst.insert(1,"wusir") 
  print(lst)
  
  
  

• remove()**指定元素删除

  name = ['bigox','xo','ox']
  name.remove(xo)
  print(name)
  
  
  

• .clear()**清空

• .extend**()添加

  li = ["alex", "WuSir", "ritian", "barry", "wenzhou"]
  s = 'qwert'
  li.extend(s)
  print(li)
  #---------------------------
  lst = ["王志文", "张一山", "苦海无涯"]
  lst.extend(["麻花藤", "麻花不疼"])
  print(lst)
  
  
  

• .reverse()反转

  v = [1,2,3,4,5,6]
  v.reverse()
  print() #[6, 5, 4, 3, 2, 1]
  
  
  

• .sort排序

  v = [1,3,7,4,5,6]
  v.sort()
  print() 	#[1, 3, 4, 5, 6, 7]
  #v.sort()	从小到大排序(默认)
  #v.sort(reverse=True)  从大到小排序
  
  
  

五.元组tuple

• 强制转换：

  • tuple(‘adfadfasdfasdfasdfafd’)

    v1 = tuple('adfadfasdfasdfasdfafd')
    print(v1) # ('a', 'd', 'f', 'a', 'd', 'f', 'a', 's', 'd', 'f', 'a', 's', 'd', 'f', 'a', 's', 'd', 'f', 'a', 'f', 'd')
    
    
    

  • tuple([11,22,33,44])

    v1 = tuple([11,22,33,44])
    print(v1)  # (11, 22, 33, 44)
    
    
    

• 元组子元素不可变,而子元素内部的子元素是可以变的,取决于元素是否为可变对象

• 元组中如果只有一个元素,一定要添加一个逗号,否者不是元组

六.字典dict

• 字典键的数据类型不能为list和tuple,值可以为任何类型.

• .keys()取键

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

• .values()取值

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

• .items()取键值对

  for i in info.items():
  	print(i)
  
  
  

• .get()以键取值,如果键不存在返回原定结果

  info = {'k1':'v1','k2':'v2'}
  a = info.get('k1')
  print(a)	#v1
  info2 = ['11111']
  b = info.get('11111',22222)
  print(b)	#22222
  
  
  

• .update()更新_存在覆盖更新,不存在添加

  info = {'k1':'v1','k2':'v2'}
  info.update({'k1':'v0','k3':'v3'})
  print(info)	#{'k1': 'v0', 'k2': 'v2', 'k3': 'v3'}
  
  
  

七.集合set

• 无序,不可重复

• 在集合中True与数字1重复,False与数字0重复

• .add() 添加

  info = {'k1','k2'}
  info.add('k3')
  print(info)	
  
  
  

• .discard()删除

  info = {'k1','k2','k3'}
  info.discard('k3')
  print(info)	
  
  
  

• 要修改,需要先删除再添加

• .clear()清空

• .update()

  info = {'k1','k2'}
  info.update({'k1','k3','v3'})
  print(info)	#{'k1','k2','k3','v3'}
  
  
  

• .intersection() 交集

  ​ 命令后的 () 可以是集合,也可以是列表.

  info = {1,2,3}
  print(info.intersection({1,3,4}))	#{1,3}
  
  
  

• .union()并集

  info = {1,2,3}
  print(info.union({1,3,4}))	#{1,2,3,4}
  
  
  

• .difference()差集

  info = {1,2,3}
  print(info.union({1,3,4}))	#{2,4}
  
  
  

第四章 文件操作

4.1 文件基本操作

obj = open('路径',mode='模式',encoding='编码')
obj.write()
obj.read()
obj.close()

4.2 打开模式

基本模式
#打开文件
f=open('要打开文件路径',mode='r/w/a/',encoding='文件原来编码') #f为接收变量
#操作文件
data = f.()  # 读取文件内部全部内容,data为接收内容
f.write('要写内容')
#关闭文件
f.close()

#文件打开新操作,自动关闭
with open('text.txt',mode= 'a',encoding='utf-8') as v:
    data = a.read()
# 缩进中的代码执行完毕之后自动关闭

• r / w / a

• r+ / w+ / a+

• rb / wb / ab

• r+b / w+b / a+b

  w/wb

  • w 模式传入的是字符串,写入时计算机进行了两步操作:

    1. 将写入内容根据指定编码encoding转换为对应二进制语言

       # 字符串转化为二进制
       mes = '示例'
       a = mes.encode('utf-8')
       #二进制文件转化为字符串
       mes = '01010101010100'
       a = mes.decode('utf-8')
       
       

    2. 将二进制写入到文件里

       • 一般用于文字写入

  • wd 模式传入的是二进制文件,想写入字符串需要进行转换操作

    1. 要把写入内容先转化为二进制语言(encode)
    2. wd再将二进制文件写入文件
       • 一般用于图片/音频/视频/未知编码写入

  r/rb

  • r 读取时计算机进行了两步操作:
    1. 读取硬盘上的二进制
    2. 按照指定编码转换成对应文件
  • rb 读取到的是二进制数据,不进行任何转换.

  a/ab

  • 用法类比w/r

4.3 操作

• read() , 全部读到内存

• read(1)

  • 1表示一个字符

    obj = open('a.txt',mode='r',encoding='utf-8')
    data = obj.read(1) # 1个字符
    obj.close()
    print(data)
    
    

  • 1表示一个字节

    obj = open('a.txt',mode='rb')
    data = obj.read(3) # 1个字节
    obj.close()
    
    

• write(字符串)

  obj = open('a.txt',mode='w',encoding='utf-8')
  obj.write('中午你')
  obj.close()
  
  

• write(二进制)

  obj = open('a.txt',mode='wb')
  
  # obj.write('中午你'.encode('utf-8'))
  v = '中午你'.encode('utf-8')
  obj.write(v)
  obj.close()
  
  

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

  obj = open('a.txt',mode='r',encoding='utf-8')
  obj.seek(3) # 跳转到指定字节位置
  data = obj.read()
  obj.close()
  
  print(data)
  
  obj = open('a.txt',mode='rb')
  obj.seek(3) # 跳转到指定字节位置
  data = obj.read()
  obj.close()
  
  print(data)
  

• tell(), 获取光标当前所在的字节位置

  obj = open('a.txt',mode='rb')
  # obj.seek(3) # 跳转到指定字节位置
  obj.read()
  data = obj.tell()
  print(data)
  obj.close()
  

• flush，强制将内存中的数据写入到硬盘

  v = open('a.txt',mode='a',encoding='utf-8')
  while True:
      val = input('请输入：')
      v.write(val)
      v.flush()
  
  v.close()
  

4.4 关闭文件

文艺

v = open('a.txt',mode='a',encoding='utf-8')

v.close()

二逼

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

4.5 文件内容的修改

with open('a.txt',mode='r',encoding='utf-8') as f1:
    data = f1.read()
new_data = data.replace('飞洒','666')

with open('a.txt',mode='w',encoding='utf-8') as f1:
    data = f1.write(new_data)

• 大文件修改
  • 在大文件读取时,不能一次性读取,需要按字节read(字节数)或for循环按行读取

with open('a.txt',mode='r',encoding='utf-8') as f1,open('b.txt',mode='w',encoding='utf-8') as f2:	#打开文件a,b
    for line in f1:																				#按行取a的内容
        new_line = line.replace('666','999')													#修改内容
        f2.write(new_line)																		#修改后的写入b,完成修改

第五章 函数

5.1函数基础

• 三元(目)运算:

  v =  前面  if 条件 else 后面    #条件为真v=前面,条件为假v=后面
  #等同于
  if 条件：
  	v = '前面'
  else:
      v = '后面'   
  #示例:
  # 让用户输入值，如果值是整数，则转换成整数，否则赋值为None
  data = input('>>>')
  value =  int(data) if data.isdecimal() else None 
  
  

• 函数定义:函数是组织好的，可重复使用的，用来实现单一，或相关联功能的代码段。函数能提高应用的模块性，和代码的重复利用率。

5.1.1.基本结构

def 函数名():
    # 函数内容
    pass				#pass占位符,没有任何操作

# 函数的执行
函数名()

• 函数如果不被调用,内部代码将不被执行.

• 运行示例

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

5.1.2参数

• 参数分为动态参数和静态参数,又叫动参和形参.

  def get_list_first_data(aaa): # aaa叫形式参数(形参)
      v = [11,22,33,44]
      print(v[aaa])
  get_list_first_data(1) # 2/2/1调用函数时传递叫：实际参数（实参）
  
  

  • 小练习

    # 1. 请写一个函数，函数计算列表 info = [11,22,33,44,55] 中所有元素的和。
    
    def get_sum():
        info = [11,22,33,44,55]
        data = 0
        for item in info:
            data += item
        print(data)
    
    get_sum()
    
    # 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([99,77,66])
    v1 = [8712,123,123]
    get_list_sum(v1)
    
    # 3. 请写一个函数，函数将两个列表拼接起来。
    def join_list(a1,a2):
        result = []
        result.extend(a1)
        result.extend(a2)
        print(result)
        
    join_list([11,22,33],[55,66,77]
    
    # 4. 计算一个列表的长度
    def my_len(arg):
    	count = 0
    	for item in arg:
              count += 1
    	print(count)
    
    v = [11,22,33]
    my_len(v)
    len(v)
    
    

5.1.3 返回值return

• return后续代码不会被执行

• 只能返回一次

• 如果要返回多个数据，可先把多个数据包装成一个整体。整体返回（列表、元组、字典…）

  def caculate(a, b):
      he = a + b
      cha = a - b
      return (he, cha)
  
  

• 小练习

  # 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('写入成功')
  else:
      print('写入失败')
         
  # 2. 写函数，计算一个列表中有多少个数字，打印： 列表中有%s个数字。
  #    提示：type('x') == int 判断是否是数字。
  """
  # 方式一：
  def get_list_counter1(data_list):
      count = 0
      for item in data_list:
          if type(item) == int:
              count += 1
  	msg = "列表中有%s个数字" %(count,)
      print(msg)
      
  get_list_counter1([1,22,3,'alex',8])
  
  # 方式二：
  def get_list_counter2(data_list):
      count = 0
      for item in data_list:
          if type(item) == int:
              count += 1
  	return count
      
  v = get_list_counter1([1,22,3,'alex',8])
  msg = "列表中有%s个数字" %(v,)
  print(msg)
  """
  
  # 2. 写函数，计算一个列表中偶数索引位置的数据构造成另外一个列表，并返回。
  """
  # 方式一：
  def get_data_list1(arg):
      v = arg[::2]
      return v
  
  data = get_data_list1([11,22,33,44,55,66])
  
  # 方式二：
  def get_data_list2(arg):
      v = []
      for i in range(0,len(arg)):
      	if i % 2 == 0:
      		v.append(arg[i])
     	return v
  
  data = get_data_list2([11,22,33,44,55,66])
  
  """
  
  # 3. 读取文件，将文件的内容构造成指定格式的数据，并返回。
  """
  a.log文件
      alex|123|18
      eric|uiuf|19
      ...
  目标结构：
  a.  ["alex|123|18","eric|uiuf|19"] 并返回。
  b. [['alex','123','18'],['eric','uiuf','19']]
  c. [
  	{'name':'alex','pwd':'123','age':'18'},
  	{'name':'eric','pwd':'uiuf','age':'19'},
  ]
  """
  #c问答案:
  def read_log(txt):#定义函数
      l=['name','age','job']
      l1 = []
      with open(txt, mode='r', encoding='utf-8') as f:
          for mes in f:#取f行,'alex|123|18','eric|uiuf|19'
              count=0
              dic={}
              for v in mes.strip().split('|'):#mes.split()切割字符串['alex','123','18']
                  dic[l[count]]=v  #取键赋值
                  count +=1
              l1.append(dic)
      print(l1)
  read_log('a.log')
  
  

5.2参数祥解

• 实际参数可以是任何值

• 函数没有返回值,默认返回None

• 函数内部执行时,遇到return就终止运行

• return可以返回任何数据类型的值,多个值时返回元组

  # enconding: utf-8
  def test():
      return 1,2,3
  print(test())		#(1, 2, 3)
  
  

5.2.1传参

• 传参:调用函数并传递参数,实参与形参必须一一对应

• 位置传参:严格按照位置先后顺序传参

• 关键字传参:直接赋值传参,无先后顺序

• 混合传参:位置参数与关键字参数混合使用,位置参数一定在关键字参数之前

  def func(a1, a2):
  print(a1, a2)
  func(a2=99,a1=2)
  # 关键字传参数和位置传参可以混合使用（位置传入的参数 > 关键字参数在后 = 总参数个数）
  def func1(a1, a2, a3):
  print(a1, a2, a3)
  # func(1, 2, a3=9)
  # func(1, a2=2, a3=9)
  # func(a1=1, a2=2, a3=9)
  # func(a1=1, 2,3) # 错误
  
  

5.2.2 默认参数

• **默认参数:**在函数建立时定义好的参数.
• 默认参数可传可不传.不传参使用默认值,传递参数相当于重新对默认参数赋值.

5.2.3 *参数 万能参数(打散)

• (*args)只接收位置参数

• 格式(*参数)可以接收多个参数,但是只支持位置传参

• 实参传递到形参时是以元组形式传递

• 传参时实参前加星(*实参),先把实参打散,再传参到形参

  def func(*args):
  print(args)
  func(1)
  func(1,2) # args=(1, 2)
  func((11,22,33,44,55)) # args=((11,22,33,44,55),)
  func(*(11,22,33,44,55)) # args=(11,22,33,44,55)
  
  

5.2.4 **参数 万能参数

• **(kwargs)

• 只接收关键

• 字参数

• 实参传递到形参时是以字典形式传递{‘k’=v}

• 传参时实参前加**,直接传递字典

  def func(*args,**kwargs):
  print(args,kwargs)
  # func(1,2,3,4,5,k1=2,k5=9,k19=999)
  func(*[1,2,3],k1=2,k5=9,k19=999)
  func(*[1,2,3],**{'k1':1,'k2':3})
  func(111,222,*[1,2,3],k11='alex',**{'k1':1,'k2':3})
  
  

注意:一般*args与**kwargs一起使用,这是超级无敌万能参数

经典例题:
#    def func(*args,**kwargs):
#        print(args,kwargs)
#    # a. 执行 func(12,3,*[11,22]) ，输出什么？
#    # b. 执行 func(('alex','武沛齐',),name='eric')
'''a.(12,3,11,22) {}
b.(('alex','武沛齐'),) {'name':'eric'}'''

参数重点总结

• 调用（执行）函数时，传参：位置参数 > 关键字参数
• 定义函数：
  • def func(a)
  • def func(a,b=None) # 对于默认值，如果是可变类型，----> 坑。
  • def func(*args,**kwargs)

5.3作用域

• 作用域就是作用范围，按照生效范围可以分为全局作用域和局部作用域。

• python

  • 一个py文件是一个全局作用域
  • 一个函数是一个作用域

• 作用域中查找数据规则:优先查找自己局域内数据,自己没有再去父级作用域查找,以此类推,可以找到,可以修改,不能为父级作用域的变量重新赋值.

• global '全局,全球’强制更改全局作用作用域 ,先global+变量,再对变量赋值

• *nonlocal ‘外地’ 强制更改**父级作用域变量 *,先nonlocal+变量,再对变量赋值

  # 示例一
  name = ["老男孩",'alex']
  def func():
      global name
      name = '我'
  func()
  print(name)
  # ############################## nonlocal
  name = "老男孩"
  def func():
      name = 'alex'
      def inner():
          nonlocal name # 找到上一级的name
          name = 999
      inner()
      print(name)
  func()
  print(name)
  

• **全局作用域:**全局作用域内的数据公用

  • 全局变量全部大写

• **局部作用域:**局部作用域可以使用全局作用域内的数据,但是全局作用域使用不了局部作用域的数据即

  • 局部变量正常变量定义

• 函数的作用域链：小范围作用域可以使用大范围的变量，但是反之不行，他是单向的。

• 函数内只可以调用全局作用域的函数

  # x = 10
  # def func():
  #     x = 9
  #     print(x)
  #     def x1():
  #         x = 999
  #         print(x)
  #     print(x)
  #     x1()
  #
  # func()
  
  # x = 10
  # def func():
  #     x = 8
  #     print(x)
  #     def x1():
  #         x = 999
  #         print(x)
  #     x1()
  #     print(x)
  #
  # func()
  
  
  # x = 10
  # def func():
  #     x = 8
  #     print(x)
  #     def x1():
  #         print(x)
  #     x1()
  #     print(x)
  #
  # func()
  
  
  
  # x = 10
  # def func():
  #     x = 8
  #     print(x)
  #     def x1():
  #         print(x)
  #     x = 9
  #     x1()
  #     x = 10
  #     print(x)
  #
  # func()
  
  

• 作用域小结

  • 函数为作用域
  • 自己 > 父级 > 父级 > 全局 【读/修改（可变）】
  • 重新赋值：
    • global 全局
    • nonlocal 外层

5.4高级函数

• 函数可以当做变量来使用:

  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(arg):
  	print(arg)
  func(1)
  func([1,2,3,4])
  def show():
  	return 999
  func(show)
  
  

• 子作用域只能读取或修改父级的值，不能重新赋值。

  #经典例题 ---------------企业面试题--------
  
  def func():
      print('花费查询')
  def bar():
      print('语音沟通')
  def base():
      print('xxx')
  def show():
      print('xxx')
  def test():
      print('xxx')
  info = {
      'f1': func,
      'f2': bar,
      'f3':base,
      'f4':show,
      'f5':test
  }
  choice = input('请选择要选择功能：')
  function_name = info.get(choice)
  if function_name:
      function_name()
  else:
      print('输入错误')
  

• 函数当做返回值

• 高级一点的内置函数(了解,懂什么意思)

  • map(函数,可迭代对象),映射函数,循环每个元素,然后让每个元素执行函数,将每个函数执行的结果保存到新的列表,并返回.

    v1 = [11,22,33,44]
    result = map(lambda x:x+100,v1)
    print(list(result)) # 特殊
    

  • fifter(函数,可迭代对象),筛选过滤,循环每个元素然后执行函数,将每个函数执行的结果筛选保存到新的列表并返回.

    result = filter(lambda x: True if type(x) == int else False ,v1)
    print(list(result))
    
    result = filter(lambda x: type(x) == int ,v1)
    print(list(result))
    

  • reduce(函数,可迭代对象),循环每个元素,然后执行函数,将每个函数执行的结果删选保存到新的列表并返回.

    import functools
    v1 = ['wo','hao','e']
    
    def func(x,y):
        return x+y
    result = functools.reduce(func,v1) 
    print(result)
    
    result = functools.reduce(lambda x,y:x+y,v1)
    print(result)
    

5.5 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 + 100 

func = lambda a1,a2: a1+100			#经典格式

• 列表所有方法返回值基本都是None,出了pop会返回要删除的元素

• 字符串所有方法返回值基本都是新值

  # 练习题
  USER_LIST = []
  func1 = lambda x: USER_LIST.append(x)
  
  v1 = func1('alex')
  print(v1)
  print(USER_LIST)
  
  # 练习题
  func1 = lambda x: x.split('l')
  
  v1 = func1('alex')
  print(v1)
  
  

5.6内置函数

• 自定义函数:自我编写函数.

• 内置函数:python系统内置函数.

• lambda表达式也叫匿名函数.

• 函数与函数之间的数据互不影响,每次运行函数都会开一个辟新的内存.

  item = 10
  def func():
      item = 2
      def inner():
          print(item)
      for item in range(10):
          pass 
      inner()
  func()
  

  • 函数销毁条件:
    • 函数运行完毕
    • 函数内部元素没有被其他使用
  • 可迭代数据类型:可被for循环的类型

  内置函数	含义
  len,open,range,id,type print,input,强制转换命令	…
  abs()	绝对值
  float()	浮点型
  max()	最大值
  min()	最小值
  sum()	求和
  divmod()	两数相除的商和余数(页面选择)
  pow()	指数运算pow(2,3)= 2**3=8
  bin()	十进制转化为二进制
  oct()	十进制转化为八进制
  int()	其他进制转化为十进制
  hex()	十进制转化为十六进制
  chr()	十进制数字转换成unicode编码中的对应字符串
  ord()	根据字符在unicode编码中找到其对应的十进制

  • len,open,range,id,type

  • print,input

  • 强制转换

  • 数学相关

    • abs，绝对值

      v = abs(-1)
      print(v)
      

    • float，转换成浮点型（小数）

      v = 55
      v1 = float(55)
      print(v1)
      

    • max，找到最大值

      v = [1,2,311,21,3,]
      result = max(v)
      print(result)
      

    • min，找最小值

      v = [1,2,311,21,3,]
      result = min(v)
      print(result)
      

    • sum，求和

      v = [1,2,311,21,3,]
      result = sum(v)
      print(result)
      

    • divmod，两数相除的商和余数

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

      # 经典______________练习题  请通过分页对数据进行展示
      """
      要求：
          每页显示10条数据
          让用户输入要查看的页面：页码
      """
      
      USER_LIST = []
      for i in range(1,836):
          temp = {'name':'你少妻-%s' %i,'email':'123%[email protected]' %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
      
      while True:
          pager = int(input('要查看第几页：'))
          if pager < 1 or pager > max_page_num:
              print('页码不合法，必须是 1 ~ %s' %max_page_num )
          else:
              """
              # 第1页：USER_LIST[0:10] -> 0123456789
              # 第2页：USER_LIST[10:20]
              # 第3页：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 = 13
      v1 = bin(num)
      print(v1)
      

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

      num = 8
      v1 = oct(num)
      print(v1)
      

    • int，将其他进制转化成十进制

      # 二进制转化成十进制
      v1 = '0b1101'
      result = int(v1,base=2)
      print(result)
      
      # 八进制转化成十进制
      v1 = '0o1101'
      result = int(v1,base=8)
      print(result)
      
      # 十六进制转化成十进制
      v1 = '0x1101'
      result = int(v1,base=16)
      print(result)
      

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

      num = 16
      v1 = hex(num)
      print(v1)
      

  • ----企业面试题------

    # 1字节等于8位
    # IP: 192.168.12.79  ->  001010010 . 001010010 . 001010010 . 001010010
    
    # 1. 请将 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))
    
    
    # 2. 请将 ip = "192.168.12.79" 中的每个十进制数转换成二进制: 
    #          0010100100001010010001010010001010010 -> 十进制的值。
    
    # 3232238671
    

5.7闭包

• 应用场景:

  • 装饰器/SQLAIchemy源码

• 函数可以作为变量

• 函数可以作为参数

• 函数可以作为返回值

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

• 闭包:为一个函数创建一块区域(内部变量供自己使用),为他以后执行提供数据

  # 基本格式
  def func(name):
      def inner():
          print(name)
  	return inner 
  
  v1 = func('alex')
  v1()
  v2 = func('eric')
  v2()
  

  #练习
  # 第一题
  name = 'alex'
  def base():
      print(name)
  
  def func():
   	name = 'eric'
      base()
  
  func() # {name=eric, }
      
  
  # 第二题
  name = 'alex'
  
  def func():
   	name = 'eric'
      def base():
      	print(name)
      base()
  func()
  
  # 第三题
  name = 'alex'
  
  def func():
   	name = 'eric'
      def base():
      	print(name)
      return base 
  base = func()
  base()
  
  

  ########################闭包企业面试题#######################

  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.8 内置模块(.py文件)

1.将指定的字符串加密:

• 将指定的字符串加密md5加密

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("sxff123ad".encode('utf-8'))#md5(加入任意字符串增加密码复杂度)
      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("gfdsjdxff123ad".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('登陆失败')

2.随机验证码模块应用:

• chr() 十进制数字转换成unicode编码中的对应字符串
• ord() 根据字符在unicode编码中找到其对应的十进制
• random.randit(最小值,最大值) 生产随机数

#生产随机验证码
import random
def get_random_code(length=6):
    data = []
    for i in range(length):
        v = random.randint(65,90)	#random.randit(最小值,最大值) 生产随机数
        data.append(chr(v))
    return  ''.join(data)
code = get_random_code()
print(code)

import random # 导入一个模块 
v = random.randint(起始,终止) # 得到一个随机数

3.密码不显示（只能在终端运行）

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

认识苦短,我学Python.每日持续更新