Python

last

琐碎

1. warning ignore

   import warnings
   warnings.filterwarnings("ignore")

2. 中文注释乱码

   # -*- coding:utf8 -*-

   放在python脚本的第一行。

3. a = np.array([1,2,3,...]) # n
   b = np.array([2,3,4,...]) # m
   c = a - b # error because n != m
   c = a.reshape(n,1)-b # produce a two-dim array (n,m)

4. ​

Number

数据类型

Python支持不同的数字类型 -

• int (有符号整数): 它们通常被称为只是整数或整数，是正的或负的整数，没有小数点。 Python3整数是无限的大小。Python 2中有两个整数类型 - int 和 long。

  在Python3中不再有 “长整型”了。

• float (点实数值) : 也叫浮点数，它们代表实数，并用小数点分割整数和小数部分。浮点数也可以用科学记数法，使用 e 或 E 表示10的幂 (2.5e2 = 2.5 x 102 = 250).

• complex (复数) : 格式是 a + bJ，其中a和b是浮点数，而J(或j)代表-1的平方根(这是一个虚数)。 实数是a的一部分，而虚部为b。复数不经常使用在 Python 编程了。

数值类型转换

• 类型 int(X)是将x转换为纯整数
• 类型 long(x) 将 x 转换为一个长整型
• 类型 float(x) 将 x 转换为浮点数
• 类型 complex(x) 将 x 转换成具有实数部分x和虚部为零的复数
• 类型 complex(x, y) x和y转换成一个带x实部和y为虚部的复数。x和y是数值表达式

数值函数

随机函数

random.choice()

以下是 choice() 方法的语法：

random.choice( seq ) ##seq是一个列表、元组或者字符串，返回一个随机选择的值

import random
print(random.choice(range(100)))
# 31
print(random.choice('HelleWorld'))
# r
print(random.choice([1, 2, 3, 5, 9]))
# 3

random.randrange()

randrange()方法的语法：

randrange ([start,] stop [,step]) ##该方法从给定范围内返回一个随机项

• start — 范围的开始点。这个起点包括在该范围内。默认值为0
• stop — 停止的范围点。这个点不包含在这个范围内
• step — 递增值。默认值为1

random.random()

返回范围[0,1]内的随机值

random.shuffle()

random.shuffle (lst) ##返回重新洗牌列表。

import random

list = [20, 16, 10, 5];
random.shuffle(list)
print(list)
# [16, 20, 10, 5]
random.shuffle(list)
print(list)
# [10, 16, 20, 5]

random.unform()

random.uniform(x, y) ##介于[x,y)的均分布随机值,返回一个浮点数 r，使得 x <= r < y

三角函数

常量

字符串

字符串访问

要访问子字符串，用方括号以及索引或索引来获得子切片

字符串更新

字符串是常量，不能直接修改，但是可以通过字符串拼接，修改。

s = 'hello x world'
s = s[:6]+"wq "+s[8:]
print(s)
# hello wq world

字符串特殊操作符

字符串格式化%

print ("My name is %s and weight is %d kg!" % ('Zara', 21)) 
# My name is Zara and weight is 21 kg!

字符串内置函数

List(列表)

逗号分隔列表中元素，列表重要的一点是，在列表中的项目不必是同一类型。

list1 = ['physics', 'chemistry', 1997, 2000];
list2 = [1, 2, 3, 4, 5 ];
list3 = ["a", "b", "c", "d"];

与字符串索引类似，列表的索引从0开始，并列出可切片，联接，等等。

访问列表值

要访问列表值，请使用方括号连同索引或索引切片获得索引对应可用的值。例如 -

list1 = ['physics', 'chemistry', 1997, 2000]
list2 = [1, 2, 3, 4, 5, 6, 7 ]
print ("list1[0]: ", list1[0])
print ("list2[1:5]: ", list2[1:5])

当执行上面的代码，它产生以下结果 -

list1[0]:  physics
list2[1:5]:  [2, 3, 4, 5]

列表值更新

可以通过给赋值运算符到左侧切片更新列表中的单个或多个元素， 并且可以使用 append()方法中加入一元素。例如 -

list = ['physics', 'chemistry', 1997, 2000]
print ("Value available at index 2 : ", list[2])
list[2] = 2001
print ("New value available at index 2 : ", list[2])

当执行上面的代码，它产生以下结果 -

Value available at index 2 :
1997
New value available at index 2 :
2001

删除列表值

del list[index] #删除index处的值

list = ['physics', 'chemistry', 1997, 2000]
print (list)
del list[2]
print ("After deleting value at index 2 : ", list)
# ['physics', 'chemistry', 1997, 2000]
# After deleting value at index 2 :  ['physics', 'chemistry', 2000]

列表基本操作

列表内置函数

函数名	功能描述
cmp(list1, list2)	列表元素比较，返回0,1,-1,
len(list)	列表长度
max(list)	返回列表中最大值
min(list)	列表中最小值
list(seq)	转化为list
append(ele)	元素添加到列表
count(ele)	统计元素在列表中出现次数
extend(list)	合并list
index(ele)	返回列表中 ele 对象对应最低索引值
insert(index, ele)	插入 ele 对象到列表的 index 索引位置,index必须给出
pop([index=-1])	根据index删除元素，默认删除最后一个
remove(ele)	删除ele元素
reverse()	列表翻转
sort()	列表元素排序

append()

list1 = ['C++', 'Java', 'Python']
list1.append('C#')
print ("updated list : ", list1)
# updated list :  ['C++', 'Java', 'Python', 'C#']

extend()

list1 = ['physics', 'chemistry', 'maths']
list2=list(range(5)) 
list1.extend( list2)
print ('Extended List :',list1)
# Extended List : ['physics', 'chemistry', 'maths', 0, 1, 2, 3, 4]

count()

aList = [123, 'xyz', 'zara', 'abc', 123];
print ("Count for 123 : ", aList.count(123))
print ("Count for zara : ", aList.count('zara'))
# Count for 123 :  2
# Count for zara :  1

Tuple元组

元组是不可变的Python对象的序列，元组序列就像列表，元组和列表之间的区别是，元组不像列表那样不能被改变以及元组使用圆括号，而列表使用方括号，创建一个元组是将不同的逗号分隔值。

tup1 = ('physics', 'chemistry', 1997, 2000)
tup2 = (1, 2, 3, 4, 5 )
tup3 = "a", "b", "c", "d"
print(tup1,tup2,tup3)
# ('physics', 'chemistry', 1997, 2000) (1, 2, 3, 4, 5) ('a', 'b', 'c', 'd')

为了编写含有一个单一的值，必须包含逗号，即使只有一个值的元组 −

tup1 = (50,)

元素访问

要访问值元组，用方括号带索引或索引切片来获得可用的索引值

tup1 = ('physics', 'chemistry', 1997, 2000)
tup2 = (1, 2, 3, 4, 5 )
tup3 = "a", "b", "c", "d"
print(tup1[1]) # chemistry
print(tup2[:2]) # (1, 2)
print(tup3[2:]) # ('c', 'd')

元素更新

元组是不可变的，这意味着我们不可以更新或更改元组元素的值。如下面的例子说明了可以把现有的元组创建新的元组的部分

tup1 = ('physics', 'chemistry', 1997, 2000)

#TypeError: 'tuple' object does not support item assignment
#tup1[0] = 100
t_add = (100,)
tup1 = t_add + tup1[1:]
print(tup1)

元素删除

移除个元组的别元素是不可能的。如要明确删除整个元组，只需要用 del 语句。

tup = ('physics', 'chemistry', 1997, 2000);
del tup;

基本操作

内置函数

Python字典

每个键是从它的值由冒号(:)，即在项目之间用逗号隔开，整个东西是包含在大括号中。没有任何项目一个空字典只写两个大括号，就像这样：{}.

键在一个字典中是唯一的，而值则可以重复。字典的值可以是任何类型，但键必须是不可变的数据的类型，例如：字符串，数字或元组这样的类型。

访问字典中的值

要访问字典元素，你可以使用方括号和对应键，以获得其对应的值。

更新字典

可以通过添加新条目或键值对，修改现有条目，或删除现有条目

删除字典

可以删除单个字典元素或清除字典的全部内容。也可以在一个单一的操作删除整个词典。

要明确删除整个词典，只要用 del 语句就可以做到。

字典键

1. 每个键对应多个条目是不允许的。这意味着重复键是不允许的。当键分配过程中遇到重复，以最后分配的为准。例如 -

   dict = {'Name': 'Zara', 'Age': 7, 'Name': 'Manni'}
   print ("dict['Name']: ", dict['Name'])
   ## dict['Name']:  Manni

2. 键必须是不可变的。这意味着可以使用字符串，数字或元组作为字典的键，但是像[‘key’]是不允许的。

内置函数

1. fromkeys()

   使用seq的值作为键，来设置创建新的字典。

   dict.fromkeys(seq[, value]))

   参数

   • seq — 这是将用于字典键准备值的列表。
   • value — 这是可选的，如果提供的话则这个值将被设置为字典的值

   

2. get()

   返回给定键的值。如果键不可用，那么返回默认值 - None。

   dict.get(key, default=None)

   参数

   • key — 这是在字典中被搜索的键。
   • default — 这是以防键不存在对应值时，则使用这个值返回。

   

3. update()

   添加字典dict2键值对到字典dict