python笔记之基本数据类型
python基本数据类型
运算符
算数运算符
a,b = (10,20)
| 运算符 | 描述 | 实例 |
|---|---|---|
| + | 加 - 两个对象相加 | a + b 输出结果 30 |
| - | 减 - 得到负数或是一个数减去另一个数 | a - b 输出结果 -10 |
| * | 乘 - 两个数相乘或是返回一个被重复若干次的字符串 | a * b 输出结果 200 |
| / | 除 - x除以y | b / a 输出结果 2 |
| % | 取模 - 返回除法的余数 | b % a 输出结果 0 |
| ** | 幂 - 返回x的y次幂 | a**b 为10的20次方， 输出结果 100000000000000000000 |
| // | 取整除 - 返回商的整数部分（向下取整） |
>>> 9//2
4
>>> -9//2
-5
|
比较运算符
a,b = (10,20)
| 运算符 | 描述 | 实例 |
|---|---|---|
| == | 等于 - 比较对象是否相等 | (a == b) 返回 False。 |
| != | 不等于 - 比较两个对象是否不相等 | (a != b) 返回 true. |
| <> | 不等于 - 比较两个对象是否不相等。python3 已废弃。 | (a <> b) 返回 true。这个运算符类似 != 。 |
| > | 大于 - 返回x是否大于y | (a > b) 返回 False。 |
| < | 小于 - 返回x是否小于y。所有比较运算符返回1表示真，返回0表示假。这分别与特殊的变量True和False等价。 | (a < b) 返回 true。 |
| >= | 大于等于 - 返回x是否大于等于y。 | (a >= b) 返回 False。 |
| <= | 小于等于 - 返回x是否小于等于y。 | (a <= b) 返回 true。 |
赋值运算符
以下假设变量a为10，变量b为20：
| 运算符 | 描述 | 实例 |
|---|---|---|
| = | 简单的赋值运算符 | c = a + b 将 a + b 的运算结果赋值为 c |
| += | 加法赋值运算符 | c += a 等效于 c = c + a |
| -= | 减法赋值运算符 | c -= a 等效于 c = c - a |
| *= | 乘法赋值运算符 | c *= a 等效于 c = c * a |
| /= | 除法赋值运算符 | c /= a 等效于 c = c / a |
| %= | 取模赋值运算符 | c %= a 等效于 c = c % a |
| **= | 幂赋值运算符 | c **= a 等效于 c = c ** a |
| //= | 取整除赋值运算符 | c //= a 等效于 c = c // a |
逻辑运算符
a,b = (10,20)
| 运算符 | 逻辑表达式 | 描述 | 实例 |
|---|---|---|---|
| and | x and y | 布尔"与" - 如果 x 为 False，x and y 返回 False，否则它返回 y 的计算值。 | (a and b) 返回 20。 |
| or | x or y | 布尔"或" - 如果 x 是非 0，它返回 x 的值，否则它返回 y 的计算值。 | (a or b) 返回 10。 |
| not | not x | 布尔"非" - 如果 x 为 True，返回 False 。如果 x 为 False，它返回 True。 | not(a and b) 返回 False |
示例
#and or not # 优先级，()> not > and > or print(2 > 1 and 1 < 4) print(2 > 1 and 1 < 4 or 2 < 3 and 9 > 6 or 2 < 4 and 3 < 2) # T or T or F #T or F print(3>4 or 4<3 and 1==1) # F print(1 < 2 and 3 < 4 or 1>2) # T print(2 > 1 and 3 < 4 or 4 > 5 and 2 < 1) # T print(1 > 2 and 3 < 4 or 4 > 5 and 2 > 1 or 9 < 8) # F print(1 > 1 and 3 < 4 or 4 > 5 and 2 > 1 and 9 > 8 or 7 < 6) # F print(not 2 > 1 and 3 < 4 or 4 > 5 and 2 > 1 and 9 > 8 or 7 < 6) # F # ps int ----> bool 非零转换成bool True 0 转换成bool 是False print(bool(2)) print(bool(-2)) print(bool(0)) #bool --->int print(int(True)) # 1 print(int(False)) # 0
成员运算符
| 运算符 | 描述 | 实例 |
|---|---|---|
| in | 如果在指定的序列中找到值返回 True，否则返回 False。 | x 在 y 序列中 , 如果 x 在 y 序列中返回 True。 |
| not in | 如果在指定的序列中没有找到值返回 True，否则返回 False。 | x 不在 y 序列中 , 如果 x 不在 y 序列中返回 True。 |
身份运算符
身份运算符用于比较两个对象的存储单元
| 运算符 | 描述 | 实例 |
|---|---|---|
| is | is 是判断两个标识符是不是引用自一个对象 | x is y, 类似 id(x) == id(y) , 如果引用的是同一个对象则返回 True，否则返回 False |
| is not | is not 是判断两个标识符是不是引用自不同对象 | x is not y ， 类似 id(a) != id(b)。如果引用的不是同一个对象则返回结果 True，否则返回 False。 |
字符串
字符串常用功能：移除空白 分割 长度 索引 切片
字符串切片
a[start:end:step]
例子
s1 = 'hello world' print(s1[0:8]) #结果是 hello wo print(s1[0:8:2]) #结果是 hlow
字符串常用方法
len
len方法，计算字符串当的长度
s1 = "abc" len(s1) #结果是 3
find
find方法，在字符串中查找子串，如果可以找到，就返回子串的第一个字符的索引，否则就返回-1
s1 = 'hello world' s1.find('e') # 结果是1 s1.find('x') # 结果是 -1
index
count方法，在字符串中查找指定元素是否存在，存在就返回index
s1 = 'hello world' print(s1.index('h')) #结果是 0
count
count方法，查找指定的元素在列表中出现了多少次
s1 = 'hello world' print(s1.count('l')) #结果是 3
join
join方法，是一个非常重要的字符串方法，用于合并序列的元素
l1 = ['hello', 'world'] s1 = " ".join(l1) print(s1) #结果是 hello world
replace
replace方法，将指定的子串都替换为另一个字符串，并返回替换后的结果
s1 = 'hello world' print(s1.replace('h','HJ') ) #结果是 HJello world
strip
strip方法，将字符串开头和末尾的空白(但不包括中间的空白)删除，将返回删除的结果
s1 = ' hello world ' print(s1.strip()) #结果是 'hello world' s2= '*190 190 190*' print(s2.strip('*')) #结果是 '190 190 190'
split
split方法，是一个非常重要的字符串方法，其作用余join相反，用于将字符串拆分为序列
s1 = 'wuhan zhangcheng beijin' print(s1.split() ) #结果是 ['wuhan', 'zhangcheng', 'beijin'] //全分割 print(s1.split(maxsplit=1)) #maxsplit:最多分隔几次, #结果是 ['wuhan', 'zhangcheng beijin'] print(s1.split()[2] ) #结果是 'beijin' s2 = 'wuhan zhangcheng.zc' #以逗号为分隔符, print(s2.split('.',maxsplit=1)) #结果是 ['wuhan zhangcheng', 'zc']
center
center方法，通过在两边填充字符(默认为空格)，让字符串居中
print('zc'.center(10,'*')) #10是总长度，*是填充符 #结果是 '****zc****' print('zc'.center(3,'*') ) #结果是 '*zc' print('zc'.center(4,'*') ) #结果是 '*zc*'
just
使用ljust及rjust函数扩充字符串位数，不足用特殊字符填充
print('zc'.ljust(4,'*')) #结果是'zc**' print('zc'.rjust(4,'*')) #结果是'**zc'
upper
uppper方法，将字符串转换为大写输出
s1 = 'zxxc' print(s1.upper()) #结果是 'ZXXC'
lower
lower方法，将字符串转为小写输出
s1 = "ASD" print(s1.lower()) #结果是 'asd'
title
title方法，将字符串每个单词首字母大写
s1 = 'my name is zhangcheng' print(s1.title() ) #结果是 'My Name Is Zhangcheng'
capitalize
capitalize方法，只对一个首字母大写
str = 'my name is zhangcheng' print(str.capitalize()) #结果是 'My name is zhangcheng'
startswitch
startswitch方法，以什么为开头
print("hello".startswith("h")) #结果是 True print("hello".startswith("e")) #结果是 False
endswitch
endswitch方法，以什么为结尾
print("hello".endswith("o")) #结果是 True print("hello".endswith("h") ) #结果是 False
max
max方法，返回最大的字符
print(max('aAcC') ) #结果是 c
min方法，返回最小的字符串
print(min('aACc')) #结果是 A
判定字符串格式
# isupper() 有字母且均为大写则为True print("AAAAAA".isupper()) #结果是True print("AAAAAb".isupper()) #结果是False # islower() 有字母且均为小写则为True print("aaaa".islower()) #结果是True print("aaaaZ".islower()) #结果是False # istitle() 从左到右所有单词首字母大写 则为True print("I Have A Book!".istitle()) #结果是True print("I Have a Book!".istitle()) #结果是False
字符串格式化
Python的字符串格式化有两种方式: 百分号方式、format方式 百分号的方式相对来说比较老，而format方式则是比较先进的方式，企图替换古老的方式，目前两者并存
百分号方式 %s %d %f
%s 字符串的格式化
%d 数字的格式化
%f 浮点数的格式化
>>print("name %s,%s" %('zx','xx'))
'name zx,xx'
>>print("age%d" %(18))
'age18'
>>print("浮点数%7.2f" %(12.36)) # 7是长度，2是小数后几位
'浮点数 12.36'
>>print("浮点数%*.*f"%(20,4,12.23)) #20是长度，4是保留几位小数
'浮点数 12.2300'
>>print("浮点数%-*.*f"%(20,4,12.23)) #-号是左对齐
'浮点数12.2300
>>print("浮点数%0*.*f"%(20,4,12.23))
'浮点数000000000000012.2300'
format方式
>>print("name:{},age:{}".format("zc","18"))
'name:zc,age:18'
>>print("name:{0},age:{1}".format("zc","18"))
'name:zc,age:18'
>>print("name:{1},age:{0}".format("zc","18"))
'name:18,age:zc'
>>print("name:{1},{0},{1},age:{0}".format("zc","18"))
'name:18,zc,18,age:zc'
列表介绍
list的表达方式: [ ], 本质上是可以改变的序列
列表示例：
1.打印列表中的索引和元素：
for index,value in enumerate(b):
print("index:%d,value:%s" %(index,value))
a = [1,2,1,['zc','zx',1,2],4,1,1,1,1]
for i in a:
print(i)
2.打印某个值的index：
list_l = [1,1,2,3,4,3,2,1]
for index,value in enumerate(list_l):
if value == 2:
print(index)
>>x = list('perl')
>>print(x)
>['p', 'e', 'r', 'l']
>>x[2:] = list('ra')
>>print(x)
['p', 'e', 'r', 'a']
可将切片替换为长度与其不同的序列
>>x = list('perl')
>>print(x)
['p', 'e', 'r', 'l']
>>x[2:] = list('hello')
>>print(x)
['p', 'e', 'h', 'e', 'l', 'l', 'o']
替换
在不替换原有元素的情况下插入新元素，“替换”了一个空切片，相当于插入了一个序列
x = ['1', '2', '3']
x[11100:1] = [6,7,8]
print(x)
#结果是 ['1', '2', '3', 6, 7, 8]
可采取相反的措施来删除切片
x = ['1','2', '3', 6, 7, 8 ]
x[1:5] = []
print(x)
#结果是 ['1', 8]
修改列表
列表赋值
x = [1, 1, 1]
x[1] = 2
print(x)
#结果是 [1, 2, 1]
嵌套列表的使用
a = [1,2,3,['a','b','c']]
print(a[3])
#结果是：['a', 'b', 'c']
print(a[3][0])
#结果是 'a'
range 迅速产生一个列表
a = list(range(10))
print(a)
#结果是 [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
ret = [i for i in range(100)]
print(ret)
#结果是： [0,1,2,......,99]
ret2 = [i*i for i in range(10)]
print(ret2)
#结果是 [0, 1, 4, 9, 16, 25, 36, 49, 64, 81]
ret3 = [chr(i) for i in range(ord('a'),ord('a')+26)]
print(ret3)
#结果是 ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z']
删除元素
a = [1,2,1,4,1,1,1,1]
for i in range(a.count(1)):
a.remove(1)
print(a)
#结果是 [2,4]
列表常用方法
append
方法append用于将一个对象附加到列表末尾。
lst = [1, 2, 3]
lst.append(4)
print(lst)
#结果是 [1, 2, 3, 4]
a = ['1', '2', '3']
b = ['4', '5', '6']
a.append(b)
print(a)
#结果是 ['1', '2', '3', ['4', '5', '6']]
insert
方法insert用于将一个对象插入列表。
numbers = [1, 2, 3, 5, 6, 7]
numbers.insert(3, 'four')
print(numbers)
#结果是 [1, 2, 3, 'four', 5, 6, 7]
pop
不指定索引，就默认删除最后一个元素，指定索引的话，就删除与索引对应的元素，删除完成之后，并返回这一元素
x = [1, 2, 3]
print(x.pop())
#结果是 3
x = [1,2]
print(x.pop(0))
#结果是 1
print(x)
#结果是 [2]
remove
方法remove用于删除第一个为指定值的元素。
x = ['to', 'be', 'or', 'not', 'to', 'be']
x.remove('be')
print(x)
#结果是 ['to', 'or', 'not', 'to', 'be']
方法count计算指定的元素在列表中出现了多少次
x = ['to', 'be', 'or', 'not', 'to', 'be']
print(x.count('to'))
#结果是 2
clear
方法clear就地清空列表的内容
lst = [1, 2, 3]
lst.clear()
print(lst)
#结果是 []
del
删除元素和变量
x = [1,2,3,4,5,6,7]
del x[0]
print(x)
#结果是 [2, 3, 4, 5, 6, 7]
del x
print(x)
#结果报错，列表不存在，NameError: name 'x' is not defined
sort
方法sort用于对列表就地排序。就地排序意味着对原来的列表进行修改，使其元素按顺序排列，而不是返回排序后的列表的副本。
x = [4, 6, 2, 1, 7, 9]
x.sort()
print(x)
#结果是 [1, 2, 4, 6, 7, 9]
sorted
方法sorted返回一个排好序的列表，源列表不变
x = [1,3,5,23,3,4]
sorted(x)
#结果是 [1, 3, 3, 4, 5, 23]
print(x)
#结果是 [1, 3, 5, 23, 3, 4]，源列表不变
max和min
输出列表中最大值和最小值
x = [1, 3, 5, 23, 3, 4]
print(max(x))
#结果是23
print(min(x))
#结果是1
copy
copy方法 ,copy 复制列表。前面说过，常规复制只是将另一个名称关联到列表。
浅拷贝
a = [1, 2, 3]
b = a
b[1] = 4
print(a)
#结果是 [1, 4, 3]
print(id(a))
#结果是 10044840
print(id(b))
#结果是 10044840
import copy
#结果是
a = [1, 2, 3]
b = copy.deepcopy(a)#或者使用b = a.copy()
# 要让a和b指向不同的列表，就必须将b关联到a的副本
b[1] = 4
print(a)
#结果是 [1, 4, 3]
print(id(a))
#结果是 10044840
print(id(b))
#结果是 10044840
extend
方法extend让你能够同时将多个值附加到列表末尾，为此可将这些值组成的序列作为参数提供给方法extend。换而言之，你可使用一个列表来扩展另一个列表。
a = [1, 2, 3]
b = [4, 5, 6]
a.extend(b)
print(a)
#结果是 [1, 2, 3, 4, 5, 6]
index
方法index在列表中查找指定值第一次出现的索引
knights = ['We', 'are', 'the', 'knights', 'who', 'say', 'ni']
print(knights.index('who'))
#结果是 4
方法reverse按相反的顺序排列列表中的元素（我想你对此应该不会感到惊讶）
x = [1, 2, 3]
x.reverse()
print(x)
#结果是 [3, 2, 1]
# 注意到reverse修改列表，但不返回任何值（与remove和sort等方法一样）
list
list方法，将其他元素转换为列表
s = "china"
s1 = list(s)
print(s1)
#结果是 ['c', 'h', 'i', 'n', 'a']
字典
字典：是一个无序的容器，由键值对组成，不同键值对用逗号隔开，键和值用冒号隔开，键要唯一，且是可hash对象 不可变对象，int str tuple；值是list set tuple dict 可变对象
如：dict = {"name":'eric', "age":18, "fav":[ "pingpong",'footbool'] }
字典赋值 dict_a["xxx"]=value xx存在则覆盖，不存在则追加。
示例：
dict = {"name":'eric', "age":18, "fav":[ "pingpong",'footbool'] }
dict["name"] = "zhangcheng"
dict["salary"] = 10000000
print(dict)
#结果是 {'name': 'zhangcheng', 'age': 18, 'fav': ['pingpong', 'footbool'], 'salary': 10000000}
get
a = {1:'zc',2:'zx'}
print(a.get(1))
#结果是 'zc'
获取所有的键
a = {1:'zc',2:'zx'}
print(a.keys())
#结果是 dict_keys([1, 2])
values
获取所有的值
a = {1:'zc',2:'zx'}
print(a.values())
#结果是 dict_values(['zc', 'zx'])
将字典的key转换成列表
a = {1: 'zc', 2: 'zx', 'zhangcheng': 123}
print(list(a))
#结果是 [1, 2, 'zhangcheng']
pop
将某个键值对给删除，通过键值来获取：
a = {1: 'zc', 2: 'zx', 'zhangcheng': 123}
print(a.pop(1))
#结果是 'zc'
print(a)
#结果是 {2: 'zx', 'zhangcheng': 123}
popitem
随机移除一个键值对，并以元组的形式返回
a = {2: 'zx', 'zhangcheng': 123}
print(a.popitem())
#结果是 ('zhangcheng', 123)
print(a)
#结果是 {2: 'zx'}
clear
清空一个字典
b = {'a': 1, 'b': 2, 'c': 3}
b.clear()
print(b)
#结果是 {}
del
删除一个字典
b = {"age":"18"}
del b
print(b)
#结果是
# Traceback (most recent call last):
# File "<pyshell#77>", line 1, in <module>
# b
# NameError: name 'b' is not defined
copy
a = {'a': 1, 'b': 2, 'c': 3}
b = a.copy()
print(b)
#结果是 {'a': 1, 'b': 2, 'c': 3}
c = dict.fromkeys([1,2,3],'OK')
print(c)
#结果是 {1: 'OK', 2: 'OK', 3: 'OK'}
dict
print(dict([('a',1),('b',2)]))
#结果是 {'a': 1, 'b': 2}
items
同时获取一个键值对的键和值
a = {1:3,2:4,3:5}
print(a.items())
print(list(a.items()))
#结果是 dict_items([(1, 3), (2, 4), (3, 5)])
#结果是 [(1, 3), (2, 4), (3, 5)]
zip
快速构建字典
print(zip([1,2],[2,3,4]))
#结果是 <zip object at 0x03592260>
print(list(zip([1,2],[2,3,4])))
#结果是 [(1, 2), (2, 3)]
Keys = [1,2,3,4,5,6]
Values = [3,4,5,6,7,8]
print(dict(zip(Keys,Values)))
#结果是 {1: 3, 2: 4, 3: 5, 4: 6, 5: 7, 6: 8}
集合
set 定义空集合：a=set()
{1,2,3,4}
集合中元素必须为不可变对象。 可hash对象集合元素是不重复的，唯一的。
集合常用方法
add
a = {1, 2, 36, 5564, 14}
a.add(40)
print(a)
# {1, 2, 36, 40, 14, 5564}
update
把原来集合中没有的元素重其他集合导入、更新
a = {1,2,3}
a.update({4,5,6})
print(a)
#{1, 2, 3, 4, 5, 6}
remove
删除集合中元素，如果元素不存在则报错
a = {1,2,3,4, 5, 6}
a.remove(6)
print(a)
#{1, 2, 3, 4, 5}
a = {1,2,3,4, 5, 6}
a.remove(0)
print(a)
#Traceback (most recent call last):
# File "F:/study/python/code/demo/demo_list.py", line 10, in <module>
# a.remove(0)
# KeyError: 0
discard
a = {1,2,3,4, 5, 6}
a.discard(6)
print(a)
#{1, 2, 3, 4, 5}
a.discard(0)
print(a)
# {1, 2, 3, 4, 5}
set
set的简易用法：删除重复的元素
lst = [1,1,2,3,2,23,45,6,6]
new_lst = list(set(lst))
print(new_lst)
# [1, 2, 3, 6, 45, 23]
集合求交集
a = {1,2,3,4}
b = {4,5,6,7}
print(a & b)
# {4}
print(a.intersection(b))
# {4}
集合求并集
a = {1,2,3,4}
b = {4,5,6,7}
print(a | b)
# {1, 2, 3, 4, 5, 6, 7}
print(a.union(b))
# {1, 2, 3, 4, 5, 6, 7}
集合求差集
a = {1,2,3,4,5,6,7}
b = {4,5,6,7}
print(a - b)
# {1, 2, 3}
print(a.difference(b))
# {1, 2, 3}
元组
元祖 只读列表，可循环查询，可切片。
>>> tu = (1,2,3,[1,2,3])
>>> tu[0] = 100
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: 'tuple' object does not support item assignment
>>> tu[-1][0] = 100
>>> tu
(1, 2, 3, [100, 2, 3])
>>> t = ()
>>t
()
>>> print(type(t))
<class 'tuple'>
>>> t = tuple()
>>> t
()
>>> print(type(t))
<class 'tuple'>
>>> t = (1) 此时t是数字类型
>>> print(type(t))
<class 'int'>
>>> t = (1,)
>>> print(type(t))
<class 'tuple'>
查看元素为1的index
>>a = (1,'zc')
>>a.index(1)
0
count
查看元素出现的次数
>>a = (1,'zc')
>>a.count(1)
1
元组和列表之间的相互转换，使用tuple和list方法:
>>a = [1,2,3]
>>b = tuple(a)
>>b
(1, 2, 3)
>>c = list(b)
>>c
[1, 2, 3]
推导式
ret = [i for i in range(1,11) if i%2 == 0 ]
print(ret)
#[2, 4, 6, 8, 10]
例二：10以内可以被2整除的数的平方
ret = [i*i for i in range(1,11) if i%2 == 0]
print(ret)
# [4, 16, 36, 64, 100]
例三:找到嵌套列表中名字含有两个‘e’的所有名字
names = [['Tom', 'Billy', 'Jefferson', 'Andrew', 'Wesley', 'Steven', 'Joe'],
['Alice', 'Jill', 'Ana', 'Wendy', 'Jennifer', 'Sherry', 'Eva']]
ret = [ name for lst in names for name in lst if name.count('e') >= 2]
print(ret)
# ['Jefferson', 'Wesley', 'Steven', 'Jennifer']
例一：将一个字典的key和value对调
mcase = {'a': 10, 'b': 34}
mcase_frequency = {mcase[k]: k for k in mcase}
print(mcase_frequency)
# {10:'a' , 34:'b'}
例二：合并大小写对应的value值，将k统一成小写
mcase = {'a': 10, 'b': 34, 'A': 7, 'Z': 3}
mcase_frequency = {k.lower(): mcase.get(k.lower(), 0) + mcase.get(k.upper(), 0) for k in mcase}
print(mcase_frequency)
# {'a':17,'b':34,'z':3}
squared = {x*x for x in [1, -1, 2]}
print(squared)
# {1, 4}
str_a = "hello"
ret = 1000 if len(str_a) >= 3 else 1
print(ret)
# 1000
