整数
二进制
n1 = 0b1010
八进制
n2 = 0o567
十六进制
n3 = 0xfdc2
浮点数
一般形式
n1 = 3.14
科学计数法
n2, n3 = 3.2e6, 1.2e-3
简单数学函数
内建函数
abs(num):
返回数的绝对值
n1, n2, n3 = 1, 0, -1
print(abs(n1), abs(n2), abs(n3)) # 1 0 1
max(num) 和 min(num):
参数不定长
n1, n2, n3, n4 = 1, 2, 3, 4
print(max(n1, n2), min(n2, n3 , n4)) # 2 4
接收可迭代对象
li = [1, 2, 3, 4]
print(max(li)) # 4
round(num, n]):
四舍五入
n表示四舍五入的小数位数,不写默认是0(取整)
pi = 3.14159
print(round(pi)) # 3
print(round(pi, 3)) #3.142
math模块中的函数
ceil():
用来向上取整
import math
pi = 3.14159
print(round(pi)) # 3
print(math.ceil(pi)) # 4
print(round(pi + 0.5)) # 可以替代ceil()
floor():
用来向下取整
import math
x = 3.678
print(round(x)) # 4
print(math.floor(x)) # 3
print(floor(x - 0.5)) # 可以替代floor()
sqrt():
平方根运算
import math
print(math.sqrt(16)) # 4
print(math.sqrt(17)) # 4.123105635
随机函数
random():
import random
print(random.random()) # 生成[0, 1)的一个小数
choice(seq):
import random
li = [1, 2, 4, 5]
print(random.choice(li)) # 从对应的列表中随机选择一个元素
uniform(x, y):
import random
print(random.uniform(1, 3) # 得到[1, 3]之间的随机小数
randint(x, y):
import random
print(random.randint(1, 5)) # [1, 5]之间的随机整数
randrange(start, stop, step):
import random
print(random.randrange(2, 10, 2) # 参数类型与range()函数一样
相当于random.choice([2, 4, 6, 8])
三角函数
import math
angle = 1 / 6 * math.pi # 30°, pi/6
res1 = math.sin(angle) # 接收弧度值
angle = math.radians(30) # 将角度值转换为弧度值
res1 = math.cos(angle)
布尔类型
是 int 的子类型,计算时会自动转换为 int
True = 1, False = 0
可以与整数进行运算
print(2 + True) # 3
print(1 + False) # 1
是一种单独的类型
flag, tag = True, False
可以当作判定条件使用
if True:
todo
字符串
字符串表示方式
str = 'abc' # 单引号对
str = "abc" # 双引号对
str = '''abc''' # 三个单引号
str = """abc""" # 三个双引号
混合表示,去掉字符串两端的限制符号就得到字符串数据
可以避免使用引号的转义来表示引号
str = "his name is 'rity', that is a good name"
使用转义字符来完成
str = "his name is 'rity', that is a good name"
消除字符串的转义
str1 = "That's all"
str2 = r"That's all"
print(str1) # That's all
print(str2) # That's all
字符串的跨行表示
str = "his name is 'rity', "
"that is a good name"
str = ("his name is 'rity', "
"that is a good name")
"""
可以直接在三对双引号内进行换行
多用于程序段的注释
---end---
"""
字符串的操作
一般操作
字符串拼接
res1 = "abc" + "def"
print(res1) # abcdef
res2 = "abc" "def"
print(res2) # abcdef
res3 = "%s%S" % ("abc", "def")
print(res3) # abcdef
字符串的乘法
res = "a" * 3
print(res) # aaa
字符串的切片
str = "abcdefg"
获得单个字符
print(str[3]) # d
print(str[-1]) # g
获得字符串片段
str[start:end:step]
默认值:start=0, end=len(str), step=1
获得范围 [start, end)
print(str[::]) # abcdefg
print(str[0:len(str):1]) # agcdefg
print(str[::2]) #aceg
print(str[::-1]) #gfedcba
函数操作
len():
可用于所有可迭代对象
计算字符串中字符的个数
name1, name2 = "rity", "瑞迪"
print(len(name1), len(name2)) # 4 2
find():
查找子串的索引
find(substr, start, end)
默认值:start=0, end=len(str)
str = "abcdabefg"
print(str.find("ab")) # 0
print(str.find("ab", 1)) # 4
print(str.find("xy")) # -1
count():
计算子字符串出现的个数
count(sub, start, end)
默认值:start=0, end=len(str)
str = "abcda"
print(str.count("a")) # 2
print(str.count("a", 2) # 1
print(str.count("x")) # 0
replace():
用给定的新字符串替换旧的字符串
replace(old, new, count)
默认值:count(省略),全部替换
str = "abacad"
print(str.replace("a", "A")) #AbAcAd
print(str.replace("a", "A", 2)) #AbAcad
print(str) # abacad
ljust() 和 rjust():
对字符串进行长度调整(扩长)
ljust(width, fillchar)
width:要扩展到的长度,fillchar:填充的字符
str = "abc"
print(str.ljust(6, "x")) # abcxxx
print(str.rjust(6, "x")) # xxxabc
print(str) # abc
lstrip() 和 rstrip() 和 strip()
移除字符串指定位置的字符
lstrip(str)
默认值:str是空字符集
name = "xi am rity ."
print(name.lstrip("ix")) # | am rity .|
print(name.rstrip(". ") # |xi am rity|
print(name.strip("ix.")) # | am rity |
split():
将父字符串分割成几个子字符串
split(sep=None, maxsplit=-1)
sep:要分割的字符,maxsplit:最大分割次数
默认值:maxsplit(省略),全部分解
返回字符串列表
info = "rity,nanchang,158-7926-7420"
res = info.split(",")
print(res) # ['rity', 'nanchang', '158-7926-7420']
多个分隔符连续的一种情况
num = "12 3 4"
res = num.split(" ")
print(res) # ['12', '', '3', '4']
省略分隔符的一种情况
str = "a c b "
res = str.split()
print(res) # ['a', 'c', 'b'] 省略首尾的空白字符,将中间连续的空白字符视作一个分隔符进行分隔
partition():
把整个字符串分三部分
partition(sep)
从左往右找
返回一个元组(分隔符左侧, 分隔符, 分隔符右侧)
pi = 3.14159
res1 = pi.partition(".")
res2 = pi.partition("-")
print(res1) # ('3', '.', '14159')
print(res2) # ('3.14159', '', '')
join():
用指定的字符串,对可迭代参数进行拼接,返回字符串
"xx".join(iterable)
与split()的作用相反
li = ["137", "9878", "0098"]
res1 = "-".join(li)
res2 = "".join(li)
print(res1) # 137-9878-0098
print(res2) # 13798780098
isalpha(), isdigit(), isalnum()
str1, str2, str3, str4, str5 = "agcD", "123", "2j3e4ef", ""
print(str1.isalpha()) # True
print(str2.isdigit()) # True
print(str4.isalnum()) # True
print(str5.isalpha(), str5.isdigit(), str5.isalnum()) # False False False
startswith() 和 endswith()
是否以某个前缀开头/结尾,范围 [start, end)
startswith("xx", start, end)
默认值:start=0, end=len(str)
name = "2018-08-09: xxx报告"
file = "xxx.md"
print(name.startswith("2018")) # True
print(file.endswith(".md")) # True
列表
有序可变元素的集合
表示方式
元素类型单一
li = ["a", "b", "c"]
多种类型的元素
li = ["a", "b", 1, 2, True]
列表可以相互嵌套
li = [[1, 2, 3], 2, True, "hehe"]
list()函数,参数为可迭代对象
li = list(range(1, 4)) # [1, 2, 3]
li = list("abc") # ('a', 'b', 'c')
列表推导
nums = [1, 2, 3, 4, 5]
li = [n*n for n in nums if n % 2]
print(li) # [1, 9, 25]
常用操作
append():
向列表的尾部添加元素
nums = [1, 2, 3, 4]
nums.append(5)
print(nums) # [1, 2, 3, 4, 5]
insert:
向列表中的任意位置插入元素
nums = [1, 2, 3, 4]
nums.insert(1, 9)
print(nums) # [1, 9, 2, 3, 4]
extend():
合并两个列表
nums1, nums2 = [1, 2], [3, 4]
nums1.extend(nums2)
print(nums1) # [1, 2, 3, 4]
del语句:
nums = [1, 2, 3]
del nums[0]
print(nums) # [2, 3]
del用来删除所引用的对象
pop():
移除并返回列表中指定索引的元素
pop(index)
默认值:index(不写),删除返回最后一个
nums = [1, 2, 3]
res = nums.pop()
print(nums, res) # [1, 2] 3
remove():
移除列表中指定的元素
remove(obj)
若元素不存在会报错,若有多个元素,删除最左边的那个
names = ["Rity", "Jack", "Tom"]
names.remove("Jack")
print(names) # ["Rity", "Tom"]
遍历删除元素会出现错误
元素删除后影响了列表的结构,进而影响了遍历的过程
nums = [1, 2, 2, 3, 4, 2]
for n in nums:
if n == 2:
nums.remove(n)
print(nums) # [1, 3, 4, 2]
index():
获得元素所在的索引值,查找范围:[start, end)
index(obj, start, end)
默认值:start=0, end=len(list)
li = [12, 34, 99]
idx = li.index(34)
print(idx) # 1
count():
获得其中某个元素的个数
li = [1, 1, 2, 3, 5]
print(li.count(1)) # 2
切片:参考字符串切片
列表遍历:
索引问题
val = ["a", "b", "a", "d"]
currentIdx = 0 # 解决index("a")恒为0的问题
for v in val:
idx = val.index(v, currentIdx)
print(idx, v)
currentIdx += 1
建立索引列表
idxList = list(range(0, len(val)))
for idx in idxList:
print(idx, val[idx])
利用枚举对象
val = ["a", "b", "c", "d"]
print(list(enumerate(val))) # [(0, 'a'), (1, 'b'), (2, 'c'), (3, 'd')]
for idx, val in enumerate(val):
print(idx, val)
排序
----------------------------------------
使用内建函数 sorted(),可以对所有可迭代对象排序
sorted(itrearble, key=None, reverse=False)
不改变原对象,以列表的形式返回处理后的结果
默认按照升序排列
s = "acgehijd"
res = sorted(s)
print(res) # ['a', 'c', 'd', 'e', 'g', 'h', 'i', 'j']
print(sorted(s), reverse=True) # ['j', 'i', 'h', 'g', 'e', 'd', 'c', 'a']
指定关键字进行排序
def getKey(x):
return x[1]
li = [("s0", 18), ("s1", 17), ("s2", 16)]
res0, res1 = sorted(li), sorted(li, key=getKey)
print(res0) # [("s0", 18), ("s1", 17), ("s2", 16)]
print(res1) # [("s2", 15), ("s1", 17), ("s0", 18)]
-----------------------------------------
使用列表的对象方法
直接修改原对象
参数列表与 sorted()相同
li = [1, 3, 5, 2, 0]
li.sort()
print(li) # [0, 1, 2, 3, 4, 5]
乱序
打乱列表中元素的顺序
直接修改原对象
import random
li = [1, 2, 3, 4, 5]
random.shuffle(li)
print(li) # [2, 4, 3, 1, 5]
反转
使用reverse()直接修改原对象
li = [1, 2, 4, 0]
li.reverse()
print(li) # [0, 4, 2, 1]
使用切片操作获得新的对象
li = ["ss", "yu", "sfj"]
res = li[::-1]
print(li, res) # ["ss", "yu", "sfj"] ['sfj', 'yu', 'ss']
元组
有序的不可变的元素集合,切片和根据索引获得单个元素的方式和列表相同。
表示方法
单元组
t = (1,)
多元组
t1, t2 = (1, 2), (2, 3, 9, 0)
复合元组
t = ("abc", [1, 2], 666)
嵌套元组
t = ("rity", (18, "nanchang"))
tuple()函数,用法与list()相同
拆包操作
t = (1, 2, 3)
a, b, c = t
print(a, b, c) # 1 2 3
字典
无序、可变的键值对的集合
表示方式
key不能重复,若有重复,后定义的覆盖前面定义的
key的类型必须是不可变的类型
可变类型(列表,字典,可变集合)
不可变类型(数值,布尔,字符串,元组)
Python的字典是通过哈希(hash)的方式实现的,计算键的哈希值,存储在哈希表中。
person = {"name": "rity", "age": 18}
print(person, type(person)) # {'name': 'rity', 'age': 18} '
print(person["name"]) # rity
print(person["age"]) # 18
d = dict.fromkeys("abc", 666)
print(d) # {'a': 666, 'b': 666, 'c':666}
添加元素
d = {"name": "s1", "age": 18}
d["height"] = 175
d["height"] = 180 # 若键已经存在,则会修改原来对应的值
不同机器上打印的结果可能不同,因为字典是无序的
print(d) # {'age': 18, 'name': 's1', 'height': 175}
使用 d0.update(d1)
将两个字典合并,若旧字典中有对应的 key,则更新;否则添加
d.update({"year": 1997, "height":180})
删除元素
d = {"name": "s1", "age": 18}
使用 del直接删除键值
删除不存在的键值对会直接报错
del d["name"]
print(d) # {"age": 18}
del d["name1"] # KeyError: 'name1'
dic.pop()
删除指定的键值对,并返回对应的值
删除不存在的键值对会直接报错
v = d.pop("age")
print(v, d) # 18 {'name': 's1'}
dic.popitem()
删除按升序排序后的第一个键值对,并以元组的形式返回键值对
字典为空报错
res = d.popitem()
print(res) # ('age', 18)
dic.clear()
清空字典,空字典,不是未定义的对象
d.clear()
print(d) # {}
del d
print(d) # 报错
获得元素
d = {"name":"Rity", "age": 18}
下标访问
print(d["name"]) # Rity
print(d["height") # 报错,键不存在
dic.get(key, default)
键不存在不会报错,default是键不存在时的返回值,默认为 None
print(d.get("age")) # 18
print(d.get("height")) # None
print(d.get("height", 170) # 170
遍历
d = {"name":"Rity", "age": 18}
#-------------------------------------
下面三种方法返回的是一个 Dictionary view objects, 虽然以列表的形式展现,但严格来说不是列表
不支持索引访问,但可以使用 list()来转换成普通的列表对象
特点:当字典被修改后,以下 ks, vs, itms会同步修改
获取所有的键
ks = d.keys()
print(ks) # dict_values(['Rity', 18])
获取所有的值
vs = d.values()
print(vs) # dict_keys(['name', 'age'])
获取所有的键值对
itms = d.items()
print(itms) #dict_items([('name', 'Rity'), ('age', 18)])
#-------------------------------------
字典是可迭代对象,使用 for in
若直接遍历字典,得到的是它的键
for x in d.items():
print(k, end=' ') # ('name':'Rity') ("age":18)
元组解包
for k, v in d.items():
print(k, v, sep='-') # name-Rity age-18
集合
无序的,不可随机访问的,不可重复的元素集合
与数学中的集合类似,可以进行集合的交、并、差、补等操作。
分为可变集合和不可变集合
set: 可以进行增、删、改操作
frozenset: 创建好之后,无法再做修改。
可变集合的表示
直接表示
s = {1, 2, 3, 4}
print(s, type(s)) # {1, 3, 4, 2}
set(Iterable)
s1 = set("abc")
s2 = set([1, 2, 3])
print(s1, s2) # {'a', 'b', 'c'} {1, 2, 3}
集合推导
参考列表推导
s = {x for x in range(3)}
print(s) # {1, 0, 2}
不可变集合
frozenset(iterable)
fs = frozenset("abc")
print(fs) # frozenset({'a', 'c', 'b'})
集合推导
fs = frozenset(x**2 for x in range(1, 6) if x % 2)
print(fs) # frozenset({1, 25, 9})
注意事项
创建空集合
错误做法
s = {} # 实际上构建了一个空字典
s = set() # 空集合
集合中的元素必须是可哈希的值(不可变类型)。
集合中元素若出现重复,则会被合并成一个。
多用于给列表元素进行去重
li = {1, 2, 2, 3, 3}
li = list(set(li))
print(li) # [1, 2, 3]
集合的操作
单集合操作
s = {1, 2, 3}
#-----------------------------------------
新增元素
1.集合可变 2.新增元素可哈希
s.add(4)
print(s) # {1, 3, 2, 4}
#-----------------------------------------
删除元素
1.remove(element)
删除指定的元素,若无该元素,报错
s.remove(2)
print(s) # {1, 3}
2.discard(element)
删除指定的元素,若无该元素,pass
s.discard(2)
print(s) # {1, 3}
s.discard(666)
print(s) # {1, 3}
3.pop(element)
删除并返回指定元素,若无该元素,报错
省略 element,不指定删除元素,进行随机删除;集合为空,报错
s.pop(1)
print(s) # {2, 3}
s.pop()
print(s) # {2}
s.pop()
print(s) # set() //空集合的意思
4.clear()
清空集合,集合依然存在
s.clear()
print(s) # set()
#-----------------------------------------
遍历集合
1.for in
for v in s:
print(s, sep=' ') # 1 2 3
2.迭代器
its = iter(s)
print(next(its)) # 1
print(next(its)) # 2
print(next(its)) # 3
多集合操作
intersection(iterable):
求交集,参数是可迭代类型
s1, s2 = {1, 2, 3, 4, 5}, {9, 8, 8, 5, 4}
res = s1.intersection(s2)
print(res) # {4, 5}
s1也可以是frozenset,返回结果也是frozenset
可以使用逻辑运算符来完成
print(s1 & s2) # {4, 5}
intersection_update(iterable)
更新调用该方法的对象
s1, s2 = {1, 2, 3, 4, 5}, {9, 8, 8, 5, 4}
s1.intersection_update(s2)
print(s1) # {4, 5}
union(iterable):
求并集,参数是可迭代类型
s1, s2 = {1, 2, 3}, {2, 3, 4}
res = s1.union(s2)
print(res) # {1, 2, 3, 4}
可以使用逻辑运算符来完成
print(s1 | s2) # {1, 2, 3, 4}
update(iterable)
s1, s2 = {1, 2, 3}, {2, 3, 4}
s1.update(s2)
print(s1) # {1, 2, 3, 4}
difference(iterable)
求差集
s1, s2 = {1, 2, 3}, {2, 3, 4}
res = s1.difference(s2)
print(res) # {1}
逻辑运算符
print(s1 - s2) # {1}
difference_update(iterable):
s1, s2 = {1, 2, 3}, {2, 3, 4}
s1.difference_update(s2)
print(s1) # {1}
判定操作
isdisjoint() 两个集合是否不相交
isuperset() 一个集合是否包含另一个集合
issubset() 一个集合是否包含于另一个集合
时间日历
time模块
获得当前时间戳
获得从 1970年1月1日到现在的时间秒数
import time
t = time.time()
yearSpan = t / (60 60 24 * 365)
print(yearSpan) # 48.6441059296045
获得时间元组
根据所给的时间戳,返回当时的时间信息
import time
t = time.time()
res = localtime(t)
print(res) # time.struct_time(tm_year=2018, tm_mon=8, tm_mday=12, tm_hour=10, tm_min=22, tm_sec=4, tm_wday=6, tm_yday=224, tm_isdst=0)
获得格式化的时间
根据所给定的时间戳,返回一个更加可读的时间
import time
t = time.time()
res = time.ctime(t)
print(res) # Sun Aug 12 10:33:58 2018
获得格式化的时间字符串
time.strftime(格式字符串, 时间元组)
res = time.strftime("%y-%m-%d %H:%M:%S", time.localtime())
print(res) # 18-08-12 10:39:28
res = time.strftime("%Y-%m-%d %H:%M:%S", time.localtime())
print(res) # 2018-08-12 10:39:50
获取当前cpu时间
常用来统计一段代码的执行时间
import time
IDLE环境测试
start = time.clock()
for i in range(0, 10)
print(i, end=' ')
end = time.clock()
print(end - start) # 0.02806393769252448
休眠
线程休眠
每隔一秒打印一个数字
import time
n = 0
while True:
print(n)
time.sleep(1) # 参数单位是秒
datetiem模块
模块内部有多个类:datetime、date、time。使用时选择合适的类进行操作就行了
获取当天的日期
import datetime
t = datetime.datetime.now()
print(type(t)) #
print(t) # 2018-08-12 11:04:12.982890
print(t.year) # 2018
print(t.month) # 8
计算n天之后的日期
import datetime
t = datetime.datetime.today()
res = t + datetime.timedelta(days=7)
print(t, res, sep='|') # 2018-08-12 11:10:31.995501|2018-08-19 11:10:31.995501
获得两个日期的时间差
import datetime
first = datetime.datetime(2018, 9, 10, 12, 0, 0)
second = datetime.datetime(2018, 10, 1, 0, 0, 0)
res = second - first
print(res) # 20 days, 12:00:00
注:喜欢python + qun:839383765 可以获取Python各类免费最新入门学习资料!
转载于:https://blog.51cto.com/14186420/2349766