Concise Operation

Table of Contents

- 参考

- 快速输入

    - 输入字符串

    - 输入整数

    - 输入小数

    - 创建空对象

    - Attention

        - OJ Python的答题结果："返回非零"

        - Python中没有 i++ 或者 i--

- 数据类型

    - bool

    - 整型

    - 浮点型

    - 除法

    - 查看类与类的关系：type()函数和isinstance()函数

- 基本数据结构

    - 字符串str

        - 编码与字符的转换

        - 查看当前python（py文件）使用的字符编码

    -

    - 列表list

        - 预分配与初始化

        - 增删查改

        - （一维）列表的反转

        - 列表的排序

        - 列表list与字符串str的转换

    - 元组tuple

    - 字典dict

        - 预分配与初始化

        - 增删查改

        - 视图

    - 集合set

        - 预分配与初始化

        - 增删查改

        - 集合的运算

- 运算和控制结构

    - 运算符

        - bool() 函数的特殊用法

        - 比较运算符的连用

        - [表达式1, 表达式2][表达式3]

    - if

    - while循环

        - while 循环可使用 else 语句

    - 推导式/解析式

        - 列表推导式

        - 字典推导式

  

参考

Python 3教程	https://www.runoob.com/python3/python3-tutorial.html
runoob PDF下载地址	https://github.com/gagayuan/runoob-PDF-/tree/master/runoob/%E6%9C%8D%E5%8A%A1%E7%AB%AF

   

快速输入

输入字符串

input()函数接受整行字符串，并返回所得字符串。

str.split()：字符串分割函数

通过指定分隔符对字符串进行切片，并返回分割后的字符串列表。

   

语法：

str.split(sep = None, maxsplit = -1)[n]

   

参数说明：

sep	表示指定的分隔符，不写的话，默认是空格(' ')。如果字符串中没有给定的分隔符时，则把整个字符串作为列表的一个元素返回。
maxsplit	表示分割次数。如果指定了参数maxsplit，就会将字符串分割成 maxsplit+1 个子字符串，并且每一个子字符串可以赋给新的变量。
[n]	表示选取第n个分片，n表示返回的list中的元素下标，从0开始的。

   

输入整行字符串	s = input('prompt')
以空格分割字符串	# 分割输入的字符串以得到子串列表 # 默认以空格为分隔符，且分割所有以空格隔开的子串 str_list = input().split() name = str_list[0] field = str_list[1]    # 简洁写法 name, age = input().split()
以"/"分割字符串	# 指定以"/"为分隔符，且分割所有以"/"隔开的子串 str_list = input().split('/') name = str_list[0] field = str_list[1]

   

   

输入整数

map() 函数：根据提供的函数对指定序列做映射。

   

map(function, iterable, ...)

第一个参数 function 以参数序列中的每一个元素调用 function 函数，返回包含每次 function 函数返回值的新列表。

function

函数

iterable

一个或多个序列

返回值

Python 2.x	返回列表
Python 3.x	返回迭代器。 可用list()方法转换为列表： list1 = list(map(function, iterable))

 

demo：

# 计算平方数

def square(x) :

return x ** 2

   

# 计算列表各个元素的平方

map(square, [1,2,3,4,5])

# 值：[1, 4, 9, 16, 25]

   

# 使用 lambda 匿名函数

map(lambda x: x ** 2, [1, 2, 3, 4, 5])

# 值：[1, 4, 9, 16, 25]

   

# 提供了两个列表，对相同位置的列表数据进行相加

map(lambda x, y: x + y, [1, 3, 5, 7, 9], [2, 4, 6, 8, 10])

# 值：[3, 7, 11, 15, 19]

   

输入一个整数	用int()函数将input()所得字符串转换为整数 a = int(input())
在一行中输入多个以空格分开的整数到指定变量	先用split()函数将input()所得字符串按空格分割，得到子串列表。 然后用int()函数将子串转换为整数。 最后用map()函数返回相应的迭代器以赋值。 n, p = map(int, input().split())
在一行中输入多个以","分开的整数到指定变量	n, p = eval(input())
将一行中的整数输入到列表中	用list()函数将map()所得的迭代器转换为列表 ar = list(map(int, input().split()))

   

   

输入小数

string.atof()函数
ascii转float，将字符串转换成小数。

   

输入一个小数	import string float = string.atof(str)
输入一行小数，存在列表中	list2 = list(map(float, input().split()))

   

创建空对象

python中的所有类型（包括整数和浮点数）均会装箱，故可创建相应类型的空对象，值为默认值。

数字型的类会返回0，其他类型的返回空。

整数
浮点数
高精度decimal
分数fractions
字符串
列表list
元组tuple
字典dict

   

Attention

OJ Python的答题结果："返回非零"

1. 在python2中用了input()，或在python3中用了raw_input()。

   如果是python2提交，就要用raw_input()；

   如果是python3提交，就要用input()。

2. 列表index out of range有时候也会返回这个错误。

   

Python中没有 i++ 或者 i--

Python规定，数值对象是不可改变的。 因此，Python中没有自增和自减。

i = i + 1 相当于重新创建了一个变量 i ，而不是改变了 i 中的数值。

可如下代替自增自减：

i = i + 1

或者

i += 1

   

   

   

数据类型

bool

真	True
假	False

PS：Python中的布尔值首字母大写

   

bool() 函数：将参数转换为布尔类型。如果没有参数，则返回 False。

bool 是 int 的子类。

class bool([x])

# x -- 要进行转换的参数。 

# 返回 True 或 False。

   

整型

• 
• 对于大整数，python会自动处理。python支持大整数（无限位数）运算。

   

   

浮点型

positive_inf = float("inf") #  正无穷

negative_inf = float("-inf") #  负无穷

not_number = float("nan") #  非数

   

python查看float的最值

import sys

float_max = sys.float_info.max

float_min = sys.float_info.min

print(str(float_max) + " " + str(float_min))

float的最大值：1.7976931348623157e+308

大于0时float的最小值：2.2250738585072014e-308

小于0时float的最大值：-2.2250738585072014e-308

float的最小值：-1.7976931348623157e+308

   

   

除法

默认是小数除法
地板除
四舍五入	round( x [, n] ) 保留n位小数（四舍五入，浮点数可能会受计算机表示的精度影响从而影响四舍五入）。 默认保留整数。

   

   

查看类与类的关系：type()函数和isinstance()函数

参考	https://www.runoob.com/python/python-func-type.html
type()	如果只有第一个参数则返回对象的类型，三个参数返回新的类型对象。 isinstance()与type()区别 type() 不会认为子类是一种父类类型，不考虑继承关系。 isinstance() 会认为子类是一种父类类型，考虑继承关系。 如果要判断两个类型是否相同推荐使用 isinstance()。

   

   

   

基本数据结构

字符串str

编码与字符的转换

• ASCII码、gbk2312、Unicode（包括utf-8、utf-32等）转字符

chr(i)

i - 十进制数或者十六进制数

• 字符转编码（自动推导为ascii码、gbk2312、utf-8、utf-32等）

ord(c)

c - 字符

  

   

查看当前python（py文件）使用的字符编码

import sys

sys.getdefaultencoding()

   

string模块提供了许多常用功能，如

string.digits	数字
string.ascii_lowercase	小写字母
string.ascii_uppercase	大写字母

   

   

   

列表list

预分配与初始化

创建空列表	list1 = list() list2 = []
预分配长度为n的空列表	# *号可重复列表中的元素 list1 = [None] * n
可迭代对象转换为列表	list1 = list(seq) # list() 只接受一个可迭代序列（元组、字符串、range() 等） list2 = [iterable, …] # [] 接受多个（可迭代）对象 list3 = [*seq, …] # 用"*"传入序列     demo 用可迭代的初值初始化列表： # 可用range()函数生成序列初值 # range()函数返回的是序列，需要转化成list list1 = list(range(n)) # 等同于 list1 = [i for i in range(n)]     demo 用列表推导式剔除不需要的数据，以初始化列表： # 生成10以内的偶数 list2 = [i for i in range(11) if i % 2 == 0] # 值：[0, 2, 4, 6, 8, 10]

   

增删查改

增	增加元素 # 将元素elem追加到list1的末尾 list1.append(elem)     # 将元素elem插入到list1的第i个位置 list.insert(elem, i)     追加列表 直接+ list1 += list2 list.extend() 函数 list1.extend(list2) 用"*"访问列表中的所有对象， 再用 [] 创建列表 list3 = [*list1, *list2]
删	# 删除第一个与obj匹配的元素，无返回值 list1.remove(obj)     # 删除下标为i的元素 del list1[i]     # 返回且删除下标为i的元素 # 默认pop最后一个元素 list1.pop(index = -1)
查	# 查找元素elem在list1中第一次出现的下标 list1.index(elem)
改	list1[下标] list1[切片] list1[-1] # list1的最后一个元素   # 用"*"传入序列 *list1

   

（一维）列表的反转

# 切片

list2 = list1[::-1]

   

# reversed()函数返回可迭代对象，

# 再将可迭代对象转换为list

list2 = list(reversed(list1))

   

# list自带的方法reverse()

list1.reverse()

   

列表的排序

• sorted() 与 list.sort()

  除了返回值、是否修改原列表的区别外，两个函数均为稳定排序，他们的参数、使用方法是一致的。

# sorted()函数返回可迭代对象，

# 再将可迭代对象转换为list

list2 = list(sorted(list1))

   

# list自带的方法sort()

list1.sort()

• 逆序排序

list1.sort(reverse = True)

   

list2 = list(sorted(list1, reverse = True))

• 指定关键字key排序

  key指向函数或者lambda表达式，接受一个参数（枚举列表元素时的对象），返回一个值（要比较的对象）。

  demo 1：

# 调用len()函数，使得列表中的字符串按长度排序

list1 = ["python", "java", "rust", "pascal"]

list1.sort(key = len)

>>> ['java', 'rust', 'python', 'pascal']

   

demo 2：

class Student:

def __init__(self, name, grade, age):

self.name = name

self.grade = grade

self.age = age

def __repr__(self):

return repr((self.name, self.grade, self.age))

student_objects = [

Student('john', 'A', 15),

Student('jane', 'B', 12),

Student('dave', 'B', 10),

]

sorted(student_objects, key=lambda student: student.age) # sort by age

>>> [('dave', 'B', 10), ('jane', 'B', 12), ('john', 'A', 15)]

   

列表list与字符串str的转换

	将字符串str中的每个字符当成可迭代对象，用 list() 转换 list1 = list(str1) 将整个字符串str当成可迭代对象，用 [] 转换 str1 = "C++" str2 = "python" list1 = [str1, str2] >>> ['C++', 'python'] str.split() 切割字符串，返回切割后的字符串列表 str1 = "C++ python java" list1 = str1.split() >>> ['C++', 'python', 'java']
	str(object = '')，像print一样输出list str1 = "python" list1 = list(str1) >>> ['p', 'y', 't', 'h', 'o', 'n'] str.join(sequence)将sequence中的所有元素以str为连接符拼成一个字符串 list1 = ['p', 'y', 't', 'h', 'o', 'n'] list1 = "".join(str1) >>> python

   

   

元组tuple

tuple不可修改其中的元素，而list可以，其余操作与list相同。

• 创建元组tuple

tuple( iterable )

iterable -- 要转换为元组的可迭代序列

   

当创建只有一个元素的元组时，tuple1 = (1)会被视为整型而非元组。

解决方法：加一个逗号

tuple1 = (1, )

   

   

字典dict

预分配与初始化

创建空字典	dict1 = dict() dict1 = {}
逐对键值对初始化字典	{key: value, …} 传入键值对 dict( [ ( key, value ), … ] ) 将键值对打包为元组，再将元组打包为列表，向字典中传入该序列。
(序列，默认值)初始化字典	dict.fromkeys(seq[, val]) 返回一个新字典，以序列 seq 中的元素作为字典的键，val 为字典所有键值对应的初始值
(序列，序列)初始化字典	z2m = dict(zip([i for i in range(11)], ['1', '0', 'X', '9', '8', '7', '6', '5', '4', '3', '2'])) zip() 函数 zip() 函数用于将可迭代的对象作为参数，将对象中对应的元素打包成一个个元组，然后返回由这些元组组成的列表。     如果各个迭代器的元素个数不一致，则返回列表长度与最短的对象相同，利用 * 号操作符，可以将元组解压为列表。 zip([0, 1], ['a', 'b']) # 值：[(0, 'a'), (1, 'b')]
合并字典	dict1.update(dict2) 把字典dict2的键值对更新到dict1中。 dicts={**dict_digits, **dict_alphabet} 用"**"传入字典dict，再用"{ }"合并字典。

   

增删查改

增	dict1.update(dict2) 把字典dict2的键值对更新到dict1中。 若dict1中的key与dict2中的相同，dict1中的key对应的value会被dict2中的覆盖。 浅拷贝 shallow copy dict2 = dict1.copy() 只拷贝第一层 深拷贝 deep copy import copy list2 = copy.deepcopy(list1)
删	del dict1[key1] pop( key[ , default ] ) key: 要删除的键值 default: 如果没有 key，返回 default 值 dict1.popitem() 返回一个键值对(key,value)， 按照 LIFO（Last In First Out 后进先出）顺序规则， 即最末尾的键值对。
查	询问key是否存在 key1 in dict1 由key访问value dict1[key1] 若key不存在，则报错。 由key访问value，key不存在时返回默认值。 dict.get(key, default = None) key -- 字典中要查找的键。 default -- 如果指定键的值不存在时，返回该默认值值。 由key访问value，key不存在时添加默认值，然后返回该默认值 dict.setdefault(key, default = None) key -- 查找的键值。 default -- 键不存在时，设置的默认键值。
改	dict1[value1]

   

视图

对dict本身的修改会影响到"视图"

dict.keys()	key
dict.values()	value
dict.items()	key-value

   

demo 使用"视图"访问dict中的key-value：

lang_dict = {1: 'C++', 2: 'Java', 3: 'Python'}

for idx, val in lang_dict.items():

print(str(idx), val)

输出：

1 C++

2 Java

3 Python

   

   

demo：

• 将0~9、26个小写字母和"_"添加到字典中

# 用dict.update()方法更新字典

import string

                  

dicts = dict.fromkeys(string.digits, False)

dicts.update(dict.fromkeys(string.ascii_lowercase, False))

dicts['_'] = False

或者

# 用{**, **}的形式合并字典

import string

                  

dict_digits = dict.fromkeys(string.digits, False)

dict_alphabet = dict.fromkeys(string.ascii_lowercase, False)

dicts={**dict_digits, **dict_alphabet}

dicts['_'] = False

   

• 将函数（或者lambda表达式）作为键值，实现switch（实际上是比switch更快的二叉平衡树）

x = int(input("Enter the 1st number: "))

y = int(input("Enter the 2nd number: "))

   

def operator(o):

dict_oper ={

'+': lambda x, y: x + y,

'-': lambda x, y: x - y,

'*': lambda x, y: x * y,

'/': lambda x, y: x / y

}

return dict_oper.get(o)(x, y)

   

if __name__ == '__main__':

o = input("Enter operation here(+ - * /): ")

print(operator(o))

   

   

集合set

set中的对象不变且可哈希

frozenset（冻结的集合），不可增删元素

   

预分配与初始化

创建空集合	set1 = set() PS：set1 = {} 被视为空字典
由序列seq初始化集合	set1 = set(["C++", "Python", "Java"]) set1 = {"C++", "Python", "Java"}

   

增删查改

增	set1.add(object) 向set1中追加一个元素，要求object不变且可哈希。 set1.update(set2) 向set1中添加集合set2
删	set1.pop(key[,default]) key: 要删除的键值 default: 如果没有 key，返回 default 值 set1.remove(object) 删除set1中的元素。 若该元素不存在，则报错。 set1.discard(object) 删除s1中的元素，无论该元素是否存在。 set1.clear() 清空集合
查
改

   

集合的运算

判断是否没有公共元素	a.isdisjoint(b) a、b没有公共元素
判断子集	a.issubset(b)
判断超集	a.issuperset(b)
并集	a | b a.union(b)
交集	a & b a.intersection(b)
差集	a - b a.difference(b)
对称差	a ^ b a或b中不同时属于a和b的元素。 a ^ b =(a - b) | (b - a) a.symmetric_difference(b)

   

demo 求两个字典的相同的键值（即求键值的交集）：

d1_keys = set(d1.keys())

d2_keys = set(d2.keys())

set1 = d1_keys.intersection(d2_keys)

   

   

   

运算和控制结构

运算符

bool() 函数的特殊用法

False None 0 "" () [] {}

False

Python中，False、None、0和空的数据结构经bool() 函数转换后均为False。

非零非空的数据结构经bool() 函数转换后为True。

   

比较运算符的连用

记比较运算符为 op，

若 a op1 b op2 c，

则 (a op1 b) and (b op2 c)

   

[表达式1, 表达式2][表达式3]

若表达式3为True，则执行表达式2；

若表达式3为False，则执行表达式1。

相当于C++中的三元运算符 ? : 。

• 当表达式1、表达式2为数值或布尔值

[False, True][4 > 3]

>>> True

• 当表达式1、表达式2为函数或者lambda表达式

  要在列表表达式后加 () 表示函数。

def false():

print("判断错误")

   

   

def true():

print("判断正确")

   

   

[false, true][1 > 9]()

>>> '判断错误'

   

if

if <expr>:

<statement(s)>

elif <expr>:

        <statement(s)>

else:

        <statement(s)>

   

while循环

while 循环可使用 else 语句

while … else 在条件语句为 false 时执行 else 的语句块。

while <expr>:

    <statement(s)>

else:

    <additional_statement(s)>

   

   

推导式/解析式

enumerate(sequence, [start = 0])

enumerate() 函数用于将一个可遍历的数据对象（如列表、元组或字符串）组合为一个索引序列，
同时列出数据和数据下标，
一般用在 for 循环或者推导式中。

• sequence -- 一个序列、迭代器或其他支持迭代对象。
• start -- 下标起始位置。
• 返回 enumerate(枚举) 对象：

  [(下标, 元素), …]

   

列表推导式

demo 产生10个100以内的随机数：

from random import randint

list1 = [randint(1, 100) for i in range(10)]

   

字典推导式

demo 为列表中的元素标号，存入字典中：

lang_list = ["C++", "Java", "Python"]

lang_dict = {idx: lang for idx, lang in enumerate(lang_list, 1)}

# 值：{1: 'C++', 2: 'Java', 3: 'Python'}

   

demo 计算两个列表对应元素之和：

原数据	a = [1,2,3,4] b = [9,8,7,6]
列表推导式	c = [a[i] + b[i] for i in range(len(a))]
map() 函数	c = list(map(lambda x, y: x + y, a, b))

   

demo 统计列表元素出现的次数，结果存入字典中：

原数据	lang_list = ["C++", "Java", "Python", "C++"]
使用 dict.get()	lang_dict = {} for item in lang_list: lang_dict[item] = lang_dict.get(item, 0) + 1
字典推导式	lang_dict = {elem: lang_list.count(elem) for elem in set(lang_list)}
结果	{'C++': 2, 'Python': 1, 'Java': 1}