Python的数据类型：
- 数值型：
int、float、complex（实数和虚数）、bool - 序列对象：
str、list、tuple - 键值对：
set（集合）、dict（字典）
数字的处理函数：
- int()：取整
- round()：四舍六入五取偶（银行家算法）
- math.floor(）：向下取整
- math.ceil()：向上取整
- min()：取最小
- max()：取最大
- pow(x,y)：幂运算（等价于x**y）
- math.sqrt()：平方根
- bin()：查看数据的二进制类型（返回值是字符串类型）
- oct()：八进制
- hex()：十六进制
- type()：判断对象类型，返回的是类型，而不是字符串。
- isinstance(obj,class_or_tuple)：判断是不是类的实例，返回布尔型isinstance(6,(int,str))。
- 1+True+2.0：隐式转换
列表list
- 属性：
- 一个队列，一个排列整齐的队伍；
- 列表内的个体称为元素，由若干元素组成列表；
- 元素可以使任意对象（数字、字符串、对象、列表等）；
- 列表内的元素有顺序，可以使用索引；
- 线性的数据结构；
- 使用[]表示；
- 列表可变；
- 列表list、链表、queue（队列）、stack（栈）的差异；
- 索引，也叫下标；
- 正索引：从左至右，从0开始，为列表中每一个元素编号；
- 负索引：从右至左，从-1开始；
- 正负索引不可以超界，否则引发IndexError异常；
- 使用：
lst=list()
lst=[]
- 列表查询：
-
index(value,[start,[stop]])：
通过值value，从指定区间查找列表内的元素是否匹配；
匹配第一个就立即返回索引；
匹配不到，抛出ValueError异常； -
count(value)：
返回列表中匹配value的次数； -
时间复杂度：
index和count方法都是O(n)；
随着列表数据规模的增大，而效率下降；
-
示例：
In [67]: l1
Out[67]: [1, 3, 5, 8, 'v']
In [68]: l1.index(5)
Out[68]: 2
In [69]: l1.index('v')
Out[69]: 4
In [70]: l1.index(8,2)
Out[70]: 3
In [71]: l1.index(8,2,4)
Out[71]: 3
In [87]: l1.index(5,-4,-1)
Out[87]: 2
In [88]: l1.count(5)
Out[88]: 1
- 列表增加、插入元素：
- append(object)->None
列表尾部追加元素，返回None；
返回None就意味着没有新的列表产生，就地修改；
时间复杂度O(1)； - indert(index,object)->None
在指定的索引index处插入元素object，返回None
就意味着没有新的列表产生，就地修改；
时间复杂度为不一定；
索引超越上界，尾部追加。超越下界，头部追加； - extend(iteratable)->None
将可迭代对象的元素追加进来，返回None
就地修改 - + -> list
连接操作，将两个列表链接起来；
产生新的列表，原列表不变；不是原地修改；
本质上调用的是__add__()方法； - * -> list
重复操作，将本列表元素重复n次，返回新的列表；不是原地修改；
- append(object)->None
In [92]: l1
Out[92]: [1, 3, 5, 8, 'v', 10]
In [93]: a = l1.append(11) # 就地修改。列表是可变类型；
In [94]: a
In [95]: type(a)
Out[95]: NoneType
In [96]: print(a)
None
In [97]: l1
Out[97]: [1, 3, 5, 8, 'v', 10, 11]
In [97]: l1
Out[97]: [1, 3, 5, 8, 'v', 10, 11]
In [98]: l1.insert(100,7)
In [99]: l1
Out[99]: [1, 3, 5, 8, 'v', 10, 11, 7]
In [100]: l1.insert(1,7)
In [101]: l1
Out[101]: [1, 7, 3, 5, 8, 'v', 10, 11, 7]
In [102]: l1.insert(0,7)
In [103]: l1
Out[103]: [7, 1, 7, 3, 5, 8, 'v', 10, 11, 7]
- 列表删除元素：
- remove(value) -> None
从左至右查找第一个匹配value的值，移除
就地修改 - pop([index]) -> item
不指定索引的index，就从列表尾部弹出一个元素
执行索引index，就从索引处弹出一个元素，索引超出界限抛出一个IndexError异常。 - clear() -> None
清除所有元素剩下一个空列表。如果列表的元素很多的情况下，清空列表，会产生很多的无用对象，需要使用垃圾回收清理，会造成短时间的性能问题，所以慎用。
- remove(value) -> None
- 列表其他操作：
- reversed() -> None
将列表中的元素反转，返回None；
就地修改； - sort(key=None,reverse=False) -> None
对列表元素进行排序，就地修改，默认是升序；
reverse为True，反转，降序；
key一个函数，指定key如何排序； - lst.sort(key=functionname)
如果列表中存在一个字符型，排序可能会产生异常，此时需要定义key。 - in
成员判断；
- reversed() -> None
In [103]: l1
Out[103]: [7, 1, 7, 3, 5, 8, 'v', 10, 11, 7]
In [104]: l1.sort()
-----------------------------------------------------------
TypeError Traceback (most recent call last)
<ipython-input-104-b8f5f256bbcf> in <module>
----> 1 l1.sort()
TypeError: unorderable types: str() < int()
In [110]: l1.sort(key=str)
In [111]: l1
Out[111]: [1, 10, 11, 3, 5, 7, 7, 7, 8, 'v']
- 列表复制：
复制是将内存地址赋值给另一个变量。浅复制。
如果想要实现相互独立的复制，需要使用列表的copy()函数，不过copy也需要注意，copy函数是将列表中对象的内存地址；深复制。
In [112]: l1 = list(range(4))
In [113]: l2 = list(range(4))
In [114]: id(l1)
Out[114]: 140318928334216
In [115]: id(l2)
Out[115]: 140318936965384
In [116]: l1 == l2
Out[116]: True
In [117]: l1 is l2
Out[117]: False
In [118]: l3 = l1
In [119]: id(l3)
Out[119]: 140318928334216
In [120]: l1 == l3
Out[120]: True
In [121]: l1 is l3
Out[121]: True
In [122]: l1[2]=10
In [123]: l3
Out[123]: [0, 1, 10, 3]
In [1]: l1=[1,2,[3,4,5],6]
In [2]: l1
Out[2]: [1, 2, [3, 4, 5], 6]
In [3]: l2=l1.copy()
In [4]: l2
Out[4]: [1, 2, [3, 4, 5], 6]
In [5]: l1[2][0]=0
In [6]: l2
Out[6]: [1, 2, [0, 4, 5], 6]
In [7]: l1
Out[7]: [1, 2, [0, 4, 5], 6]
- 随机数：
random模块；
randint(a,b)，返回[a,b]之间的整数；
choice(seq)，从非空序列的元素中随机挑选一个元素，比如random.choice(range(10))，从0到9中随机挑选一个证书。random.choice([1,3,5,7])
randrange[([start],stop[,step])]从指定范围内，按指定计数递增的集合中获取一个随机数，计数缺省值为1。random.randrange(1,7,2)
random.shuffle(list) -> 就地打乱表元素。
# 求100以内的素数：
import math
for num in range(1,100):
max=int(num/2+1)
l1=[]
for a in range(2,max):
newnum=num%a
if (newnum == 0):
l1.append(a)
if (len(l1) == 0):
print(str(num) + ' is 素数。')
l1.clear()
# 注意：可以在循环里面添加count，粗略计算时间复杂度。
注意：从2开始到自身的-1的数中找到一个能这个你出的，从2开始到自身开平方的书中找到一个能整除。
注意：一个合数一定可以分解成几个素数的乘积，也就是说，一个数如果能被一个素数整除，就是合数。
import math
n = 100
pn = []
count = 0
for x in range(2,n):
count = count + 1
for i in pn:
count = count + 1
if x % i == 0: # not prime;
break
# if i > math.ceil(x**0.5): # is prime;
# pn.append(x)
# break
else:
pn.append(x)
print(pn)
print(count)
import datetime
import math
n = 1000000
pn = []
flag = False
start = datetime.datetime.now()
for x in range(2,n):
for i in pn:
if x % i == 0: # not prime;
flag = True
break
if i >= math.ceil(x**0.5): # is prime
flag = False
break
if not flag:
pn.append(x)
delta = (datetime.datetime.now() - start).total_seconds()
print('time=' + str(delta))
print(len(pn))
注意：静态语言和动态语言的差别是，动态语言赋值即定义。
注意：help(list)，注意，括号中的内容，必须是可迭代对象。
注意：列表大的情况下，inset()函数尽量少用。
注意：建议使用pop()函数。
注意："=="是判断值是否相等。"is"是判断内存地址是否相等。
扫一扫
551
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
