Python超详细

---

Python基础知识

字符串 Str

• 字符串拼接

  a = 'eagle '
  b = 'welcome '
  print(b + a,'*' * 3,a * 3)
  

  运行结果

  welcome eagle *** eagle eagle eagle
  

• 字符串索引与切片

  a = 'ABCDEFGHIJK'
  print(a[0:]) #默认到最后
  print(a[0:-1]) # -1 是列表中最后一个元素的索引，但是要满足顾头不顾腚的原则，所以取不到K元素
  

  运行结果

  ABCDEFGHIJK
  ABCDEFGHIJ
  

• 字符串常用方法

  words = "beautiful is better than ugly"
  print(words.capitalize())      #首字母大写
  print(words.swapcase())        #大小写翻转
  print(words.title())           #每个单词的首字母大写
  
  
  # 内容居中，总长度，空白处填充
  a = "test"
  ret = a.center(20, "*")
  print(ret)
  
  # 统计字符串中的元素出现的个数
  ret = words.count("e", 0, 30)
  print(ret)
  
  # startswith 判断是否以…开头
  # endswith 判断是否以…结尾
  a = "aisdjioadoiqwd12313assdj"
  print(a.startswith("a"))
  print(a.endswith("j"))
  print(a.startswith('sdj',2,5))
  print(a.endswith('ado',7,10))
  
  
  # 寻找字符串中的元素是否存在
  print(a.find('sdj',1,10)) # 返回的找到的元素的索引，如果找不到返回-1
  print(a.index('sdj',1,10)) # 返回的找到的元素的索引，找不到报错。
  
  
  # split 以什么分割，最终形成一个列表此列表不含有这个分割的元素。
  ret = words.split(' ')
  print(ret)
  ret = words.rsplit(' ',2)
  print(ret)
  
  
  # format的三种玩法 格式化输出
  print('{} {} {}'.format('aaron',18,'teacher'))
  print('{1} {0} {1}'.format('aaron',18,'teacher'))
  print('{name} {age} {job}'.format(job='teacher', name='arron', age=18))
  
  
  # strip
  a = '****asdasdasd********'
  print(a.strip('*'))
  print(a.lstrip('*'))
  print(a.rstrip('*'))
  print(a.strip())        # 去除空格
  
  
  # replace
  print(words.replace('e','a',2)) # 字符串从左向右开始，把e替换成a，一共替换两次
  print(words.isalnum()) #字符串由字母或数字组成
  print(words.isalpha()) #字符串只由字母组成
  print(words.isdigit()) #字符串只由数字组成
  

元组 tuple

元组被称为只读列表，即数据可以被查询，但不能被修改。

元组可变与不可变详解：

链接：https://blog.csdn.net/machi1/article/details/86601119

列表 List

• 增

  li = [1,'a',2,'d',4]
  li.insert(0,22) # 按照索引去增加
  print(li)
  li.append('ddd') # 增加到最后
  print(li)
  li.extend(['q,a,w']) # 迭代的去增
  print(li)
  li.extend(['q,a,w','das']) # 迭代的去增
  print(li)
  

  运行结果

  [22, 1, 'a', 2, 'd', 4]
  [22, 1, 'a', 2, 'd', 4, 'ddd']
  [22, 1, 'a', 2, 'd', 4, 'ddd', 'q,a,w']
  [22, 1, 'a', 2, 'd', 4, 'ddd', 'q,a,w', 'q,a,w', 'das']
  

• 删

  li = [1,'a',2,'d',4,5,'f']
  a = li.pop(1) # 按照位置去删除，有返回值
  print(a)
  del li[1:3] # 按照位置去删除，也可切片删除没有返回值。
  print(li)
  li.remove('f')
  print(li)
  li.clear()
  print(li)
  

  运行结果

  a
  [1, 4, 5, 'f']
  [1, 4, 5]
  []
  

• 改

  li = [1,'a',2,'d',4,5,'f']
  li[1] = 'aaa'
  print(li)
  li[2:3] = [3,'e']
  print (li)
  

  运行结果

  [1, 'aaa', 2, 'd', 4, 5, 'f']
  [1, 'aaa', 3, 'e', 'd', 4, 5, 'f']
  

• 查

  切片去查，或者循环去查。

• 其他

  li = [1,2,4,5,4,2,4]
  print (li.count(4)) # 统计某个元素在列表中出现的次数
  print (li.index(2)) # 用于从列表中找出某个值第一个匹配项的索引位置
  li.sort() # 用于在原位置对列表进行排序
  print (li)
  li.reverse() # 将列表中的元素反向存放
  print (li)
  

  运行结果

  3
  1
  [1, 2, 2, 4, 4, 4, 5]
  [5, 4, 4, 4, 2, 2, 1]
  

字典 dict

从Python3.6开始字典为有序

参考博客：https://www.cnblogs.com/xieqiankun/p/python_dict.html

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-6Zj50hau-1611720947146)(file:///D:\QQ文件\2652516133\Image\Group2@]Z@]ZKGM2PF2F1R]U]S~BTOC.png)]

• 增

  dic = {
         "age":18, "name":"aaron"}
  
  dic['li'] = ["a", "b", "c"]
  print(dic)
  
  dic.setdefault('k', 'v')
  #在字典中添加键值对，如果只有键那对应的值是none，但是如果原字典中存在设置的键值对，则他不会更改或覆盖
  print(dic)
  
  dic.setdefault('k', 'v1')
  print(dic)
  

• 删

  dic = {
         "age":18, "name":"aaron"}
  
  dic_pop = dic.pop('age')
  # pop根据key删除键值对，并返回对应的值，如果没有key则返回默认返回值
  print(dic_pop)
  
  dic['age'] = 18
  print(dic)
  
  del dic['name']
  print(dic)
  
  del dic['name']
  print(dic)
  
  dic['name'] = 'demo'
  dic_pop = dic.popitem()
  # 随机删除字典中的某个键值对，将删除的键值对以元组的形式返回
  print(dic_pop)
  
  dic_clear = dic.clear()
  # 清空字典
  print(dic,dic_clear)
  

• 改

  dic = {
         "age":18, "name":"aaron", 'sex':'male'}
  dic2 = {
         "age":30, "name":'demo'}
  
  dic2.update(dic)
  # 将dic所有的键值对覆盖添加（相同的覆盖，没有的添加）到dic2中
  print(dic2)
  
  dic2['age'] = 30
  print(dic2)
  

• 查

  dic = {
         "age":18, "name":"aaron", 'sex':'male'}
  value = dic['name']
  # 没有会报错
  print(value)
  value = dic.get('abc','查无此项')
  print(value)
  

• 其他

  dic = {
         "age":18, "name":"aaron", 'sex':'male'}
  
  for i in dic.items():
      # 将键和值作为元组列出
      print(i)
  
  for key,value in dic.items():
      print(key,value)
      
  for i in dic:
      # 只是迭代键
      print(i)
      
  keys = dic.keys()
  print(keys,type(keys))
  
  value = dic.values()
  print(value,type(value))
  

集合 set

• 创建

  set1 = set({
         1,2,'barry'})
  set2 = {
         1,2,'barry'}
  print(set1,set2)
  

• 增

  set1 = {
         'abc', 'def', 123, 'asdas'}
  
  set1.add('qwer')
  print(set1)
  
  set1.update('A')
  # update：迭代着增加
  print(set1)
  
  set1.update('哈哈哈')
  print(set1)
  
  set1.update([1, 2, 3])
  print(set1)
  

• 删

  set1 = {
         'abc','def',123,'asdas'}
  
  set1.remove('abc')
  print(set1)
  
  set1.pop()
  # 随机删除一个数
  print(set1)
  
  set1.clear()
  # 清空合集
  print(set1)
  
  del set1
  # 删除合集
  print(set1)
  

• 其他

  交集（&或者intersection）

  set1 = {
         1,2,3,4,5}
  set2 = {
         3,4,5,6,7}
  
  print(set1 & set2)
  
  print(set1.intersection(set2))
  
  # 列出两个集合中共同拥有的项
  

  并集（|或者union）

  set1 = {
         1,2,3,4,5}
  set2 = {
         3,4,5,6,7}
  
  print(set1 | set2)
  
  print(set2.union(set1))
  
  # 列出两个集合中所有的项
  

  差集（-或者difference）

  set1 = {
         1,2,3,4,5}
  set2 = {
         3,4,5,6,7}
  
  print(set1 - set2)
  
  print(set1.difference(set2))
  
  # 在set1中删除set2中有的项
  

  反交集（^或者symmetric_difference）

  set1 = {
         1,2,3,4,5}
  set2 = {
         3,4,5,6,7}
  
  print(set1 ^ set2)
  print(set1.symmetric_difference(set2))
  
  # 显示set1和set2不共存的项
  

  子集与超集

  set1 = {
         1,2,3}
  set2 = {
         1,2,3,4,5,6}
  
  print(set1 < set2)
  print(set1.issubset(set2)) # 这两个相同，都是说明set1是set2子集。
  
  print(set2 > set1)
  print(set2.issuperset(set1)) # 这两个相同，都是说明set2是set1超集
  

  frozenset不可变集合，让集合变成不可变类型

  set1 = {
         1,2,3,4,5,6}
  
  s = frozenset(set1)
  print(s, type(s))
  
  s.add(7)     # 不可以修改，会报错
  

流程控制（易忽视）

• while…else…

  while后面的else作用是指，当while循环正常执行完，中间没有被break中止的话，就会执行else后面的语句

• enumerate

  enumerate：枚举，对于一个可迭代的（iterable)/可遍历的对象（如列表、字符串），enumerate将其组成一个索引序列，利用它可以同时获得索引和值。

  li = ['甲','乙','丙','丁']
  for i in li:
  	print(i)
      
  for i in enumerate(li):
  	print(i)
      
  for index,value in enumerate(li):
  	print(index,value)
      
  for index,value in enumerate(li,100): #从哪个数字开始索引
  	print(index,value)
  

  运行结果

  甲
  乙
  丙
  丁
  (0, '甲')
  (1, '乙')
  (2, '丙')
  (3, '丁')
  0 甲
  1 乙
  2 丙
  3 丁
  100 甲
  101 乙
  102 丙
  103 丁
  

文件操作

文本文件和二进制文件

• 文本文件：可以使用文本编辑器查看；
• 二进制文件：保存的内容不是直接给人查看的，而是使用专用软件查看的，例如图片文件、视频文件；

操作文件的流程

1. 打开文件；

2. 读写文件；

3. 1.读文件：将文件内容读入内存；

   2.写文件：将内存内容写入文件

4. 关闭文件。

操作文件中的函数/方法

序号	函数/方法	说明
01	open	打开文件，并且返回文件操作对象
02	read	将文件内容读取到内存
03	write	将指定内容写入文件
04	close	关闭文件

• open 函数负责打开文件，并且返回文件对象
• read / write / close 三个方法都需要通过 文件对象 来调用

1. open函数：

2. 1. 第一个参数是文件名（文件名区分大小写），第二个参数是打开方式；

   2. 如果文件存在返回文件操作对象；

   3. 如果文件不存在抛出异常

3. read()方法：可以一次性读入并返回文件的所有内容；

4. close()方法：负责关闭文件；

# 1. 打开 - 文件名需要注意大小写
file = open("README")

# 2. 读取
text = file.read()
print(text)

# 3. 关闭
file.close()

文件打开方式

f = open("文件名", "访问方式")

访问方式	说明
r	以只读方式打开文件。文件的指针将会放在文件的开头，这是默认模式。如果文件不存在，抛出异常
w	以只写方式打开文件。如果文件存在会被覆盖。如果文件不存在，创建新文件
a	以追加方式打开文件。如果该文件已存在，文件指针将会放在文件的结尾。如果文件不存在，创建新文件进行写入
r+	以读写方式打开文件。文件的指针将会放在文件的开头。如果文件不存在，抛出异常
w+	以读写方式打开文件。如果文件存在会被覆盖。如果文件不存在，创建新文件
a+	以读写方式打开文件。如果该文件已存在，文件指针将会放在文件的结尾。如果文件不存在，创建新文件进行写入

以bytes类型操作的读写，写读，写读模式

r+b	读写【可读，可写】
w+b	写读【可写，可读】
a+b	写读【可写，可读】

对于非文本文件，我们只能使用b模式，“b"表示以字节的方式操作（而所有文件也都是以字节的形式存储的，使用这种模式无需考虑文本文件的字符编码、图片文件的jpg格式、视频文件的avi格式）

rb

wb

ab

注：以b方式打开时，读取到的内容是字节类型，写入时也需要提供字节类型，不能指定编码

• 频繁的移动文件指针，会影响文件的读写效率，开发中更多的时候会以 只读、只写 的方式来操作 文件。

按行读取文件内容

• read方法默认会把文件的所有内容一次性读取到内存；
• readline方法可以一次读取一行内容；
• 方法执行后，文件指针移动到下一行，准备再次读取；

# 方式一、通过循环按行读取文件所有内容
file1 = open("Readme.txt")
i = 1
while True:
    text1 = file1.readline().strip()
    if text1:
        print("这是第%s行内容" % i)
        i += 1
        print(text1)
    else:
        break
file1.close()

# 方式二、通过for遍历按行读取文件所有内容
file2 = open("Readme.txt")
for i in file2.readlines():
    print(i.strip())
    
file2.close()

with 结构

with open("README.txt") as file1:
	while True:
		text1 = file1.readline().strip()
		if text1:
			print("这是第%s行内容" % i)
			i += 1
			print(text1)
		else:
			break

close()在操作完毕文件后，一定要记住f.close(),推荐操作方式：使用with关键字来帮我们管理上下文

with open('a.txt','r') as read_f,open('b.txt','w') as write_f:
	data=read_f.read()
	write_f.write(data)

文件编码

f = open(…)是由操作系统打开文件，那么如果我们没有为open指定编码，那么打开文件的默认编码很明显就是操作系统说的算，操作系统会用自己的默认编码去打开文件，在Windows下是gbk，在Linux下是utf-8。

f=open('a.txt','r',encoding='utf-8')

文件操作

read(3):

1. 文件打开方式为文本模式时，代表读取3个字符
2. 文件打开方式为b模式时，代表读取3个字节

其余的文件内光标移动都是以字节为单位的如：seek，tell，truncate

注意：

1. seek有三种移动方式0，1，2，其中1和2必须在b模式下进行，但无论哪种模式，都是以bytes为单位移动的
2. truncate是截断文件，所以文件的打开方式必须可写，但是不能用w或w+等方式打开，因为那样直 接清空文件了，所以truncate要在r+或a或a+等模式下测试效果。

其他操作方法

def close(self, *args, **kwargs): # real signature unknown
	关闭文件
	pass

def fileno(self, *args, **kwargs): # real signature unknown
	文件描述符
	pass

def flush(self, *args, **kwargs): # real signature unknown
	刷新文件内部缓冲区
	pass

def isatty(self, *args, **kwargs): # real signature unknown
	判断文件是否是同意tty设备
	pass

def read(self, *args, **kwargs): # real signature unknown
	读取指定字节数据
	pass

def readable(self, *args, **kwargs): # real signature unknown
	是否可读
	pass

def readline(self, *args, **kwargs): # real signature unknown
	仅读取一行数据
	pass

def seek(self, *args, **kwargs): # real signature unknown
	指定文件中指针位置
	pass

def seekable(self, *args, **kwargs): # real signature unknown
	指针是否可操作
	pass

def tell(self, *args, **kwargs): # real signature unknown
	获取指针位置
	pass

def truncate(self, *args, **kwargs): # real signature unknown
	截断数据，仅保留指定之前数据
	pass

def writable(self, *args, **kwargs): # real signature unknown
	是否可写
	pass

def write(self, *args, **kwargs): # real signature unknown
	写内容
	pass

def __getstate__(self, *args, **kwargs): # real signature unknown
	pass

def __init__(self, *args, **kwargs): # real signature unknown
	pass

@staticmethod # known case of __new__
def __new__(*args, **kwargs): # real signature unknown
	""" Create and return a new object. See help(type) for accurate 	signature.
	"""
	pass

def __next__(self, *args, **kwargs): # real signature unknown
	""" Implement next(self). """
	pass

def __repr__(self, *args, **kwargs): # real signature unknown
	""" Return repr(self). """
	pass

案例

案例一、文件的修改

文件的数据是存放于硬盘上的，因而只存在覆盖、不存在修改这么一说，我们平时看到的修改文件，都是模拟出来的效果，具体的说有两种实现方式：

方式一：将硬盘存放的该文件的内容全部加载到内存，在内存中是可以修改的，修改完毕后，再由内存覆盖到硬盘（Word，vim，nopad++等编辑器）

import os

with open('a.txt') as read_f,open('a.txt.new','w') as write_f:
    data = read_f.read()
    data = data.replace('Hello','nihao')
    
    write_f.write(data)

os.remove('a.txt')
os.rename('a.txt.new','a.txt')

方式二：将硬盘存放的该文件的内容一行一行地读入内存，修改完毕就写入新文件，最后用新文件覆盖源文件

import os
with open('a.txt') as read_f,open('a.txt.new','w') as write_f:
	for line in read_f:
		line = line.replace('nihao','Hello')
		write_f.write(line)
        
os.remove('a.txt')
os.rename('a.txt.new','a.txt')

案例二、文件的复制

file = open("README")

while True:
	text = file.readline()
	print(text)
	if not text:
		break
file.close()
# -------------------------------------------------------------------------------
------
# 小文件复制
file1 = open("README", "r")
file2 = open("README[复件]", "w")

text = file1.read()
file2.write(text)

file1.close()
file2.close()

# -------------------------------------------------------------------------------
------
# 大文件复制
file3 = open("README", "r")
file4 = open("README[大文件复制]", "w")

while True:
	text = file3.readline()
	if not text:
		break
	file4.write(text)
    
file3.close()
file4.close()

案例三、计算总价

文件a.txt内容：每一行内容分别为商品名字，价钱，个数。

apple 10 3

tesla 100000 1

mac 3000 2

lenovo 30000 3

chicken 10 3

通过代码，将其构建成这种数据类型：[{‘name’:‘apple’,‘price’:10,‘amount’:3}, {‘name’:‘tesla’,‘price’:1000000,‘amount’:1}…] 并计算出总价钱。

list = []
with open('a.txt','r',encoding='utf-8') as file:
	for line in file:
		list2 = line.strip().split()
	if list2:
		dic = {
     'name':list2[0],'price':list2[1],'amount':list2[2]}
		list.append(dic)
	continue
    
print(list)
price = 0
for i in list:
	price += int(i['price']) * int(i['amount'])
    
print(price)