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

Python学习笔记

第一章 计算机基础

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运算优先级

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

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-73mfvnOA-1587266913477)(D:\迅雷下载\qq421E0EA568377BD15D408CE8A3C19FA2\f899990ce20548858eb947920111e9f3\ysf.png)]

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

  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)
  

第五章 函数

第六章 模块

第七章 面向对象

第八章 网络编程

第九章 并发编程

第十章 数据库

第十一章 前端开发

第十二章 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整除的添加到另外一个列表中。

     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整除的添加到另外一个列表中。