python常用函数及方法

一、 对比数据类型的优缺点

1. python的数值、字符串、元祖是不可变数据类型，而列表、字典、集合是可变数据类型。

2. 字符串、列表、元祖的内部元素是有序的，而字典、集合的内部元素是无序的。

3. 从消耗时间上比较：集合<字典<元祖<列表

4. 从占用内存上比较：字典>集合>列表>元祖

一、判断类型

id() id(a) 返回对象的标识（内存中的位置），返回值为整数。

is a is b? 比较两个对象的标识

type() type(a) 返回对象的类型

instance(object,type) instance(a,list) 检查类型

a = 0.1
b = 0.1
print(id(a), id(a)==id(b), a is b) # (94172288661952, True, True)
print(type(a))                     # <type 'float'>
print(isinstance(a,float))         # True

二、数值：int、long、float、bool、complex 不可变

abs(x)
max(x1,x2,...)
min(x1,x2,...)

# math库
import math
math.ceil()
math.floor()
math.sqrt()        # 平方根
math.log(x,base)      # 对数，x为真数，base为底数且默认为e
math.power(x,n)    # x的n次方
math.fabs()        # 绝对值
math.pi            # 圆周率
math.e             # 自然常数e


# random库
import random
random.seed(a)              # 初始化随机数种子a，可以是整数或浮点数?????????????????/
random.random()             # [0, 1)之间的随机小数
random.uniform(a,b)         # [a,b]之间的随机小数
random.randint(a,b)         # [a,b]之间的随机整数
random.randrange(m,n[,k])   # [m,n)之间以k(默认为1)为步长的随机整数. (10, 100, 2)结果相当于从[10, 12, 14, 16, … 96, 98]序列中获取一个随机数。
random.choice(seq)          # 从序列中随机选择一个元素
random.shuffle(seq)         # 将序列seq中元素随机排列,返回打乱后的序列

三、序列：字符串str

# 增
str1 +str2
str.join(sequence)       # 将序列中的元素以指定的字符连接生成一个新的字符串
# 删
# 查
str.count(sub, start= 0,end=len(string))    # 统计某个字符或子字符串出现的次数
str.startswith(str, start=0,end=len(string))
str.endswith(suffix[, start[, end]])        # 判断字符串是否以指定后缀结尾，是返回True
str.find(substr, start=0, end=len(string))       # 检测是否包含子字符串str，返回索引，否则-1
str.rfind(str, beg=0 end=len(string))            # 返回字符串最后一次出现的位置,索引还是从左开始算
str.index(substr, start=0, end=len(string))       # 同上，返回索引，否则抛出异常
str.rindex
str.isalnum()        # 检测是否由字母和数字组成，且至少一个字符，返回True
str.isalpha()        # 字母
str.isdecimal()      # 十进制数字
str.isdigit()        # 数字，只对 0 和 正数有效。
str.isnumeric()      # 是否只由数字组成。这种方法是只针对unicode对象。
str.islower()        # 检测是否都为小写字母
str.isupper()        # 检测是否都为大写
str.isspace()        # 是否只由空格组成

# 改
str.upper()                     # 小写全改大写
str.lower()                     # 大写全改小写
str.swapcase()                  # 翻转大小写
str.capitalize()                # 首字母大写
str.title()                     # 所有单词首字母大写，其他字母小写
str.lstrip([chars])             # 截掉左边的空格或指定字符
str.rstrip                      # 右边
str.replace(old, new[, max])    # 把old替换成new，不超过 max 次
str.split(str="", num=string.count(str))     # 按指定分隔符对字符串进行切片，默认num为 -1, 即分隔所有。分隔 num+1 个子字符串
str.strip([chars])              # 移除头尾指定的字符（默认为空格或换行符）。不能删除中间部分的字符

四、序列：列表list

# 增
list = ['Google', 'Runoob', 1997, 2000]
list.append(obj)          # list变，[1, 2, [3, 4]]
list.extend(seq)          # list变，[1, 2, 3, 4]
list.insert(index, obj)   # list变，在index位置插入obj:[1, 2, [3, 4]]
# 删
del l[1]
list.pop([index=-1])      # 按索引号移除列表中的一个元素（默认最后一个元素），并且返回该元素的值
list.remove(obj)          # 移除obj对象
list.clear()              # list=[], 与list = null 区别: 该方法list中的对象变成垃圾回收清空，但是list对象还是存在
# 查
len(list)
cmp(list1, list2)
max(list)                 # 返回列表元素中的最大值
list.count(obj)           # 统计obj元素在列表中出现的次数
list.index(obj[, start[, end]])   # 找出某个值第一个匹配项的索引位置
# 改
list.reverse()            # 反向排序
list.sort(cmp=None, key=None, reverse=False)     # reverse = False 升序（默认）
a = set(list)             # list不变
a = list.copy()           # 浅拷贝，指向的不是nameList在内存中的地址，而是重新复制了一份，此时两个列表在内存中的地址不同
                          # 浅拷贝意味着新列表中的任何修改都不会反映到原始列表中

# copy()
a = [1,2,3]
b = a.copy()
b[1] = 4
print(a)      # a = [1,2,3]不变

五、序列：元祖tuple

tup1 = (1,)          # 元组中只包含一个元素时，需要在后添加逗号,否则括号会被当作运算符使用
tup3 = tup1 + tup2   # 元素值不允许修改，但可以对元组进行连接组合
del tup              # 元素值不允许删除，但可以使用del语句来删除整个元组
len() max() min() tuple()

六、字典dict

# 增
dict = {}
dict[] = ;
dict.fromkeys(seq[, value])      # 新建字典，以seq为键，value为所有键对应的初始值：默认None
# 删
dict.clear()        # dict = {}
del dict            # None
del dict['Name']    # 删键
dict.pop(key[,default])   # 删键，default是当键 key 不存在时返回的值
# 查
dict.keys()       # 键 dict_keys([1, 2])
dict.values()     # 值 dict_values(['a', 'b'])
dict.items()      # 键和值 dict_items([(1, 'a'), (2, 'b')])
cmp(dict1, dict2)        # 比较两个字典元素，相同返回0，dict1大于dict2返回1，否则返回-1
dict.get(key[, value])   # 返回指定键的值，如果键不在，返回参数的vlaue值
key in dict

七、集合set

# 增
parame = {val1,val2,...}  # 可以使用大括号 { } 或者 set() 函数创建集合
set(value)
s.add(x)       # 将元素 x 添加到集合 s 中，如果元素已存在，则不进行任何操作。
# 删
s.remove(x)    # 将元素 x 从集合 s 中移除，如果元素不存在，则会发生错误。
s.discard(x) # 移除，如果元素不存在，不会发生错误。
s.pop()        # 随机删除集合中的一个元素
s.clear()      # 清空集合
# 查
s1.issuperset(s2)         # 判断s2是否是s1的子集，返回True
s1.issubset(s2)           # 判断s1是否是s2的子集，返回True
s1.isdisjoint(s2)         # 判断两个集合是否无重叠部分，如果无重叠返回True！
# 改
s1.difference(s2)         # 返回集合的差集，即返回的集合元素包含在s1中，但不包含在s2.
set.union(set1, set2...)  # 返回并集
set.intersection(set1, set2...)  # 返回交集
s1.update(s2)             # 添加新的元素或集合到当前集合