python基础知识汇总

列表

1、将列表中的字符型数字转换为数值类型
1
2
3
4
5
6
7
lis = ['1', '2', '3', '8', '6', '12']

num_lis = [int(x) for x in lis]
#或者
num_lis = list(map(int, lis))

输出结果为：[1, 2, 3, 8, 6, 12]
2、将列表中的数字转换为字符（同上）
1
2
3
4
5
6
7
lis = [1, 2, 3, 8, 6, 12]

char_lis = [str(x) for x in lis]
#或者
char_lis = list(map(str, lis))

输出结果为：['1', '2', '3', '8', '6', '12']
3、对列表中的元素进行排序
  • 如果列表中是数字，那么直接进行排序：
1
2
3
4
5
6
lis = [1, 2, 3, 8, 6, 12]

lis.sort()
print(lis)

输出结果为：[1, 2, 3, 6, 8, 12]
  • 如果列表中是字母型字符，那么也直接进行排序（根据ASCII）：
1
2
3
4
5
6
lis = ['a', 'd', 'e', 'b']

lis.sort()
print(lis)

输出结果为：['a', 'b', 'd', 'e']
  • 如果列表中是数字型字符，想要使其中的数字升序或者降序排列，需要对其进行一些操作：
1
2
3
4
5
6
7
#若直接进行排序
lis = ['1', '2', '3', '8', '6', '12']

lis.sort()
print(lis)

输出结果为：['1', '12', '2', '3', '6', '8']

注意：上述排序是按元素的第一个字符进行排序的。

1
2
3
4
5
6
lis = ['1', '2', '3', '8', '6', '12']

lis.sort(key=lambda x:int(x))
print(lis)

输出结果为：['1', '2', '3', '6', '8', '12']
4、Python 输出时去掉列表或者元组外面的方括号与圆括号

可以是使用join()函数来实现：

‘x’.join(y)，x可以是任意分割字符，y是列表或元组。以列表为例，可以将列表中的每一个元素两头的引号给去

除，同时，元素与元素之间以字符‘x’作为分割标志，并且列表最外面的中括号也能去除掉。元组同理。

1
2
3
4
5
lis = ['1', '2', '3', '8', '6', '12']

print(' '.join(lis))

输出结果为：1 2 3 8 6 12

注意：join()函数只能用于字符，不能用于数值类型。

5、列表的去重和排序

先将一个列表转换为set集合， 再转换为list列表，即可完成去重。

  • 若列表元素为数字，则既可以去重也可以排序：
1
2
3
4
5
lis = [1, 2, 3, 12, 8, 6, 3]

print(list(set(lis)))

输出结果为：[1, 2, 3, 6, 8, 12]
  • 若列表元素为字符，则只可以去重不可以排序，顺序为随机排列：
1
2
3
4
5
lis = ['1', '2', '3', '8', '6', '12', '3']

print(list(set(lis)))

输出结果为：['6', '3', '12', '1', '2', '8']

字典

  • python字典以键值对的形式存储，且键一般是唯一的，如果重复，则最后的一个键值对会替换前面的，值不需要唯一。
  • 值可以取任何数据类型，但键必须是不可变的（字符串，数字，元组）。
删除字典元素
1
2
3
4
5
dict = {'Name': 'Zara', 'Age': 7, 'Class': 'First'}
 
del dict['Name']  # 删除键是'Name'的条目
dict.clear()      # 清空字典所有条目
del dict          # 删除字典
遍历字典元素
1
2
3
4
5
6
7
8
9
10
11
12
13
dic=  {'Name': 'Zara', 'Age': 7, 'Class': 'First'}

# 遍历键
for key in dic.keys():
    print(key)

# 遍历值
for val in dic.values():
    print(val)

# 遍历键和值
for key, val in dic.items():
    print(key, val)
其他方法
序号 函数及描述
1 dict.has_key(key) 如果键在字典dict里返回true，否则返回false
2 dict.update(dict2) 把字典dict2的键/值对更新到dict里
3 dict.get(key) 返回指定键的值，如果值不在字典中返回default值
4 dict.update(dict2) 把字典dict2的键/值对更新到dict里
5 pop(key,default) 删除字典给定键 key 所对应的值，返回值为被删除的值。key值必须给出。 否则，返回default值。

数值处理

1、python向上取整，向下取整，四舍五入
1
2
3
4
5
6
import math
 
f = 5.49
print(math.ceil(f))         #向上取整 6
print(math.floor(f))        #向下取整 5
print(round(f))             #四舍五入 5
2、输出规定数位的小数
1
2
3
4
5
6
#结果保留两位小数

x = 2.3333333
print("%.2f" %x)

输出结果为：2.33
3、输出多个相同的值
1
2
3
4
5
#输出3个python

print("python"*3)

输出结果为：pythonpythonpython
4、函数有任意多个参数

将函数的参数定义为*n，n可以看作一个列表，接收实际参数。

例如定义一个函数multi()可以传入任意个参数，返回这些参数的乘积：

1
2
3
4
5
6
7
8
def  multi(*n):
	multi = 1
	for x in n:
		multi *= x
	return multi
print(multi(1,2,3))

输出结果为：6

将函数的参数定义为**n，n可以看作一个字典，接收实际参数。

1
2
3
4
5
def dictionary(**n):
	print(n)
dictionary(first=1, second=2, third=3)

输出结果为：{'first': 1, 'second': 2, 'third': 3}

循环输入

怎么样能使while循环和input输入结合起来形成循环输入呢？python不能像C语言那样直接实现

1
while(scanf("%d%d", &a,&b) != EOF)

在python中，无法通过input()的返回值判断是否有EOF。python是通过抓取异常来知EOF的，于是，通过try except的方法，当出现except的时候，就是到了EOF，这时退出循环。

1
2
3
4
5
6
7
8
9
while True :
	try :
		x = int(input())
		y = int(input())
                # 一行一个整数
		print(x+y)
	
	except :
		break
1
2
3
4
5
6
7
8
9
while True :
	try :
		s = input()
		l = s.split()
		# 一行两个整数，中间用空格隔开
        print(int(l[0])+int(l[1]))
	
	except :
		break

注意：引起异常的并不是input()本身，而是紧跟在input()函数后调用输入值的语句：print(x+y)和print(int(l[0])+int(l[1]))，因为当不从键盘上输入值即input()函数返回None时，后面的语句调用输入值时发生错误从而引发异常。若将print(x+y)和print(int(l[0])+int(l[1]))语句删去，将形成无限循环输入。

在此附上一个例子：

进行两个集合的合并，并且没有重复元素且升序排列。

输入：若干组，每组包括三行，第一行输入两个数字，分别为两个集合的元素个数；第二行和第三行分别为两个集合。

输出：若干组，每组一行，为合并后的集合。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
result = []
while True:
    try:
        x = input().split()
        x[0]  #用于引发异常
    except:
        break
    else:
        set1 = input().split()
        set2 = input().split()
        result.append(list(set(set1+set2)))
for i in range(0, len(result)):
    result[i].sort(key=lambda d:int(d))
    print(' '.join(result[i]))

结果为：

GQu974.png

时间格式转换

导入包：

1
from time import datetime
datetime格式转换为字符串：
1
2
time = datetime.now()
time_str = datetime.strftime(time, "%Y-%m-%d %H:%M:%S")
字符串转换为datetime格式
1
2
str = "2020-8-1"
time = datetime.strptime(str, "%Y-%m-%d")

正则表达式

导入
1
import re
使用
re.match函数

re.match尝试从字符串的起始位置匹配一个模式，如果不是起始位置匹配成功的话，match()就返回none。

1
2
3
4
5
re.match(pattern, string, flags=0)

# pattern：正则表达式
# string：要匹配的字符串
# flags：标志位，用于控制正则表达式的匹配方式，如：是否区分大小写，多行匹配等等

该函数返回一个match对象（如果匹配失败，返回None），如果想要得到匹配到的字符串。可以使用group()函数或groups()函数。

匹配对象方法 描述
group(num=0) 匹配的整个表达式的字符串，group() 可以一次输入多个组号，在这种情况下它将返回一个包含那些组所对应值的元组。
groups() 返回一个包含所有小组字符串的元组，从 1 到 所含的小组号。

例如：

1
2
3
4
5
6
7
import re

pattern = "\w+123"
string = "skdgh123"
print(re.match(pattern, string).group())

输出为：skdgh123
re.search函数

re.search扫描整个字符串并返回第一个成功的匹配。

1
2
3
re.match(pattern, string, flags=0)

# 参数意义同上
re.sub函数

Python 的 re 模块提供了re.sub用于替换字符串中的匹配项。

1
2
3
4
5
6
re.sub(pattern, repl, string, count=0, flags=0)

# pattern : 正则中的模式字符串。
# vrepl : 要替换成的字符串，也可为一个函数。
# string : 要被查找替换的原始字符串。
# count : 模式匹配后替换的最大次数，默认 0 表示替换所有的匹配。

例如：

1
2
3
4
5
6
7
import re

string = "hello world!"
result = re.sub('world', 'gays', string)
print(result)

输出为：hello gays!
re.compile函数

compile 函数用于编译正则表达式，生成一个正则表达式（ Pattern ）对象，供 match() 和 search() 这两个函数使用。

1
2
3
4
5
6
7
8
9
10
re.compile(pattern, flags)

# pattern : 一个字符串形式的正则表达式
# flags : 可选，表示匹配模式，比如忽略大小写，多行模式等，用“|”分隔，具体参数为：
	re.I 忽略大小写
	re.L 表示特殊字符集 \w, \W, \b, \B, \s, \S 依赖于当前环境
	re.M 多行模式
	re.S 即为 . 并且包括换行符在内的任意字符（. 不包括换行符）
	re.U 表示特殊字符集 \w, \W, \b, \B, \d, \D, \s, \S 依赖于 Unicode 字符属性数据库
	re.X 为了增加可读性，忽略空格和 # 后面的注释

例如：

1
2
3
4
5
6
7
8
import re

string = "hello world!"
pattern = re.compile(r'hello')
result = pattern.match(string)
print(result.group())

输出为：hello
findall函数

在字符串中找到正则表达式所匹配的所有子串，并返回一个列表，如果没有找到匹配的，则返回空列表。

1
2
3
4
5
findall(string, pos, endpos)

# string : 待匹配的字符串。
# pos : 可选参数，指定字符串的起始位置，默认为 0。
# endpos : 可选参数，指定字符串的结束位置，默认为字符串的长度。

例如：

1
2
3
4
5
6
7
8
import re
 
pattern = re.compile(r'\d+')   # 查找数字
result1 = pattern.findall('runoob 123 google 456')
result2 = pattern.findall('run88oob123google456', 0, 10)
 
print(result1)
print(result2)

输出结果：

1
2
['123', '456']
['88', '12']
正则表达式对象

re.RegexObject

re.compile()返回 RegexObject 对象。

re.MatchObject

  • group()返回被 RE 匹配的字符串
  • start()返回匹配开始的位置
  • end()返回匹配结束的位置
  • span()返回一个元组包含匹配 (开始,结束) 的位置

replace替换字符串

Python replace() 方法把字符串中的 old（旧字符串） 替换成 new(新字符串)，如果指定第三个参数max，则替换不超过 max 次。

1
2
3
4
5
str.replace(old, new, max)

# old -- 将被替换的子字符串。
# new -- 新字符串，用于替换old子字符串。
# max -- 可选字符串, 替换不超过 max 次

返回值：返回字符串中的 old（旧字符串） 替换成 new(新字符串)后生成的新字符串。

例如：

1
2
3
4
string = "hello world!"
print(string.replace('world', 'gays'))

输出为：hello gays!

全局变量

在python中，假设x是一个全局变量，那么在一个函数内（该函数未定义局部变量x）使用类似x += 1、x = max(x, 0)等语句时，会报错：UnboundLocalError: local variable ‘x’ referenced before assignment

例如：

1
2
3
4
x = 0
def f():
    x += 1
f()

解决方法：在函数中使用该全局变量前用globle进行声明即可

1
2
3
4
5
6
x = 0
def f():
  global x
  x += 1
  print(x)
f()

未完待续······

赏

谢谢你请我吃糖果

扫一扫，分享到微信

微信分享二维码

tag:

    缺失模块。
    1、请确保node版本大于6.2
    2、在博客根目录（注意不是yilia根目录）执行以下命令：
    npm i hexo-generator-json-content --save

    3、在根目录_config.yml里添加配置： 

      jsonContent:
    meta: false
    pages: false
    posts:
      title: true
      date: true
      path: true
      text: false
      raw: false
      content: false
      slug: false
      updated: false
      comments: false
      link: false
      permalink: false
      excerpt: false
      categories: false
      tags: true

很惭愧<br><br>只做了一点微小的工作<br>谢谢大家