整型(int)
- 1.int的用途:
用于记录整数如人的年龄,各种号码等。
- 2.定义方式:
age = 10 # age = int(10)
x = int('1156') # int只能将纯数字的字符串强制转换成十进制的整型。
print(type(x))
- 3.常用操作+内置方法
常用操作有算术运算和比较运算,暂无内置方法。
- 小结:
整型只能存一个值,是一种不可变的类型。
可变:指的是改变原值,即在原值的基础上进行修改。
可变类型:指的是在id不变的情况下,值可以改变。
不可变类型:在值改变了的情况下,id也跟着变化。
int是不可变的数据类型。
age = 10
print(id(age))
age = 11
print(id(age))
- 了解知识点:
长整型:在python3中整型本质上都是长整型,在python2中会指定Long为长整型数据。
复数(complex):
x = 1-2j
print(x.real)
print(x.imag)
print(type(x))
浮点型(float)
- 1.用途:用于表示带小数类型的数据
- 2.定义方式:
salary = 6524.76 # salary = float(6524.76)
- 3.常用操作
常用于算术运算和比较运算。
- 小结:
浮点型是只能存一个值的不可变类型。
x = 3.5
print(type(x))
x = 3.6
print(type(x))
字符串类型(str)
- 1.用途:
用于描述带有性质的数据,如人名等
- 2.定义方式:
name = "zhangsan" # name = str("zhangsan")
x = str(1)
y = str(1.3)
z = str([1, 2, 3, ])
m = str({'p':1, 'q':2})
print(type(x))
print(type(y))
print(type(z))
print(type(m))
以上可以看出,几乎任何数据类型都支持定义为字符串。
- 3.常用的操作以及内置方法:
- 一、按索引取值(正向曲、反向取):只能取值,不能改变字符串中单个字符。
msg = 'hello world'
print(type(msg[5])) #取出msg这个字符串中的第六个值并查看是什么类型的数据
print(msg[-1]) #反向取出msg字符串中第一个字符,即'd'
msg[2] = 'A' #尝试修改msg字符串中第三个字符,程序会报错
- 二、切片(顾头不顾尾,步长)
msg = 'hello world'
print(msg[1:5], type(msg[1:5])) # 正向取出msg中第一个到第四个中的字符,并查看取出该值类型
print(msg[6:-1]) #正向从msg字符串中取出第六个到倒数第二个中的字符
print(msg[6:11]) #正向取出msg字符串中第六个到第十一个中的字符
print(msg[6:]) #正向取出msg字符中从第六个到最后一个中的字符
print(msg[6::2]) #正向取出msg从第六个到最后一个按照间隔一个来取出字符
print(msg[::-1]) #反向取出msg中所有字符
print(msg[-3:-6:-1]) #反向取出倒数第三个到倒数第六个中的字符
- 三、长度(len)
msg = 'hello world'
print(len(msg))
- 四、成员运算(in和not in)
print('zhang' in 'my name is zhangsan')#输出结果是一个布尔值
print('lisi' in 'my name is zhangsan')
print('zhang' not in 'my name is zhangsan')
print(not 'lisi' in 'my name is zhangsan')
- 五、移除空白strip
name = ' zhang san '
print(name.strip(' '))# strip会移除字符串左右两边第一个不为空格字符之前的所有空格
print(name.strip())#默认即为移除空格,包含在字符中间的空格不会被移除。
name = '*********zhang**san********'
print(name.strip('*'))#strip会移除字符串左右两边第一个不为*字符之前的所有*
print(name.lstrip('*'))# 移除字符串左边的*
print(name.rstrip('*')) #移除字符串右边的*
pwd = input('>>>:').strip() ###假设输入的是 '123 '
if pwd == '123':
print('login successful')
#######使用strip并不是改变了原有的数据,而是改变了显示方式。(暂且这么理解吧......)
- 六、切分(split)
msg = 'zhangsan:23:180:140'
l = msg.split(':')#将切分的值赋给变量l(split会将切分的数据存为列表类型)
print(l)
print(l[3])#输出列表中的索引为4的值
- 七、循环
msg = 'hello world'
for i in msg:
print(x)
- 八、其他需掌握操作
1.lower,upper
name = 'zhAngsaN'
print(name.lower()) #将变量中的字母替换为小写
print(name.upper()) #将变量中的字母替换为大写
2.startswitch,endswitch
print('name is zhangsan'.startswitch('name')) #会返回一个布尔值
print('name is zhangsan'.endswitch('name')) #会返回一个布尔值
3.format
print('my age is {age},my name is {name}'.format(name = 'zhangsan',age = 18))#可以不受位置的限制,用变量名来接收所传入的值
print('my age is {},my name is {}'.format(18,'zhangsan')) #可以按照顺序的传入后面的值
print('my age is {0},my name is {1}{1}{1}'.format(18,'zhangsan')) #可以按照对应关系传入值,在这里18对应{0},zhangsan对应{1}
4.split,rsplit
info = 'zhangsan:23:180'
print(info.split(':', 1))# 正向去除到第二个元素为止的":"
print(info.rsplit(':', 1)) # 反向去除到第二个元素为止的":"
5.join(只能将元素全为字符串的列表拼成一个大的字符串)
lst = ['a', 'b', 'c']
print(':'.join(lst))#会将lst中的元素按照":"拼接成一个大字符串
lst = ['a', 1, 2]
print(':'.join(lst))#程序会报错,因为列表中的元素不全为字符串
6.replace
msg = 'name is zhangsan, zhangsan is a man'
print(msg.replace('zhangsan', 'lisi',1))# 将字符串中的第一个'zhangsan'替换为'lisi'
7.isdigit(判断一个值是否为整型)
print('111.1'.isdigit()) #会返回一个布尔值
print('1111'.isdigit()) #会返回一个布尔值
AGE = 23
age = input('>>>puts a number').strip() #键入一个值并去掉空字符
if age.isdigit():
age = int(age)
if age > AGE:
print('big')
elif age == AGE:
print('yes')
else:
print('small')
else:
print('puts a number!')
- 字符串类型总结:
字符串是一个只能存放一个值的有序的不可变类型的数据类型。有序可以理解为字符串中的元素可以按照索引来取值。
列表(list)
- 1.作用
可以用来描述多个值的一种数据类型。
- 2.定义
[]内可以有多个任意类型的值,用逗号将每个元素分隔开。列表内只能存放能被for循环遍历的数据类型
l=list('hello')
print(l)
l = list({'a':'1', 'b':'2'})
print(l)
- 3.需要掌握的一些操作
- 一、按照索引存取值(正向、反向存取)
names = ['zhangsan', 'lisi', 'xiaoming']
namesp[0] = 'ZhangSan' #将列表中的第一个元素修改
- 二、切片(顾头不顾尾,步长)
names = ['zhangsan', 'lisi', 'xiaoming']
print(names[0:3])#输出第一个和第二个元素
- 三、长度
names = ['zhangsan', 'lisi', 'xiaoming']
print(len(names))
- 四、成员运算in和not in
names = ['zhangsan', 'lisi', 'xiaoming']
print('xxx' in names)#返回一个布尔值
- 五、追加(append)
names = ['zhangsan', 'lisi', 'xiaoming']
names.append('xxx')
print(names)
- 六、删除
names = ['zhangsan', 'lisi', 'xiaoming']
del names[2]
print(names)
- 七、循环
names = ['zhangsan', 'lisi', 'xiaoming']
for name in names:
print(name)
- 八、插入
names = ['zhangsan', 'lisi', 'xiaoming']
names.insert(1,'zzz')#在索引为1的元素前面插入'zzz'
- 其他一下需要掌握的操作
1.remove
names = ['zhangsan', 'lisi', 'xiaoming']
res = names.remove('lisi') #单纯的删除,按照元素的值删除,无返回值
print(res)
print(names)
2.pop
names = ['zhangsan', 'lisi', 'xiaoming']
res = names.pop(1)# 拿走一个值,按照索引删除,有返回值
print(res)
print(names)
names = ['zhangsan', 'lisi', 'xiaoming']
print(names.pop())#默认删除最后一个元素
3.count(统计某个元素出现的次数)
names = ['zhangsan', 'lisi', 'lisi','xiaoming']
print(names.count('lisi'))
4.index(查看某个元素的索引值)
names = ['zhangsan', 'lisi', 'xiaoming']
print(names.index('lisi'))
5.clear(清空列表)
names = ['zhangsan', 'lisi', 'xiaoming']
print(names.clear())
6.copy
names = ['zhangsan', 'lisi', 'xiaoming']
x = names.copy()
print(x)
7.extend(向列表中追加一个列表)
names = ['zhangsan', 'lisi', 'xiaoming']
names.extend([1, 2, 3,])
print(names)
8.reverse(将列表翻转)
names = ['zhangsan', 'lisi', 'xiaoming']
names.reverse()
print(names)
9.sort(排序)
num = [1, 10, 3, -2]
num.sort(reverse = True)#将列表按照从大到小排序
print(num)
- 列表类型总结:
列表是一个可以存放多个值,值都可以是任意类型的数据。列表是有序的可变的数据类型。
lst = ['x','y']
print(id(lst))
lst[0] = 'a'
print(id(lst))
- 元组(tuple)
- 1.用途:
元组是不可变的列表,可以存放多个值,但多个值只有取的需求,而没有改的要求场景下使用元组最合理。
- 2.定义方式:
在()内用逗号分隔开,可以存放任意类型的值
names = ('lxx', 'wxx', 'zhangsan') # names = tuple(('lxx', 'wxx', 'zhangsan'))
当元组只有一个元素的时候,务必加一个逗号,否则会识别成字符串。
- 3.常用操作及内置方法
- 一、按索引取值(正向,反向取),只能取值,不能修改
names = ('lxx', 'wxx', 'zhangsan')
print(names[0])
- 二、切片
names = ('lxx', 'wxx', 'zhangsan')
print(names[1:3])
- 三、长度
names = ('lxx', 'wxx', 'zhangsan')
print(len(names))
- 四、成员运算in 和 not in
names = ('lxx', 'wxx', 'zhangsan')
print('cxx' in names)
- 五、循环
names = ('lxx', 'wxx', 'zhangsan')
for i in range names:
print(i)
- 总结:
元组是一个可以存放多个值,且值都可以是任意数据类型,元组是不可变的有序数据类型。
与列表对比:
列表可变:
列表可变是索引对应的值的内存地址可以改变。
元组不可变:
元组不可变指的是索引对应的值的内存地址不可改变,也可以说只要索引对应值的内存地址没有改变,那么元组就是没有改变。
有以下情况:
t1 = (['a', 'b', 'c'], 'd', 'e')
print(id(t1(0)))
print(id(t1(1)))
print(id(t1(2)))
t1[0][0] = 'A' #将t1中的第一个元素中的第一个元素修改,并非直接修改元组中的第一个元素
print(t1)
print(id(t1[0]))
字典(dict)
- 1.用途:
用来存放多个值,每一个值都有一个key与之对应,key对值有描述性的功能。
- 2.定义方式:
{}内用逗号分隔开多个元素,每一个元素都是key:value的形式,value可以是任意数据类型,但是key必须是不可变类型,key通常应该是字符串类型。
d = {'x':1, 'y':2} # d = dict{'x':1, 'y':2}
d = dict(a = 1, b = 2, c = 3)
print(d)
- 3.常用操作及内置方法
- 一、按key存取:能存能取
d = {'x':1, 'y':2}
d['x'] = 5
print(d)
d['z'] = 3
print(d)
l = ['a','b']
l[2] = c
- 二、长度len
d = {'x':1, 'y':2}
print(len(d))
- 三、成员运算 in 和not in
d = {'x':1, 'y':2}
print('x' in d)
- 四、删除
d = {'x':1, 'y':2}
del d['x']
print(d)
res = d.pop('y')
print(d)
print(res)
res = d.popitem()
print(d, res)
l = [1, 2, 3]
del l[1]
print(l)
- 五、键keys() , 值value(), 键值对items()
info = {'name':10, 'age':20, 'hobbies':3}
names = []
for k in info:
names.append(k)
print(names)
info = {'name':10, 'age':20, 'hobbies':3}
values = []
for k in info:
values.append(info[k])
print(values)
info = {'name':10, 'age':20, 'hobbies':3}
keys = info.keys()
print(keys)
for k in keys:
print(k)
info = {'name':10, 'age':20, 'hobbies':3}
vals = info.values()
print(vals)
print(list(vals))
info = {'name':10, 'age':20, 'hobbies':3}
print(info.items())
print(list(info.items()))
- 六、循环
取key
info = {'name':10, 'age':20, 'hobbies':3}
for k in info:
print(k, info[k])
for k in info.keys():
print(k, info[k])
取values
info = {'name':10, 'age':20, 'hobbies':3}
for v in info.values():
print(v)
取key和values
for k, v in info.items()
print(k ,v)
- 七、其他一些内置方法
d = {'x':1, 'y':2, 'z':3}
v = d.get('xxxx')
print(v)
print(d['xxxx'])
d = {'x':1, 'y':2, 'z':3}
d1 = {'a':9, 'b':8, 'z':7}
d.update(d1)
print(d)
l = ['name','age', 'sex']
d = {}
for k in l:
d[k] = None
d = dict.fromkeys(l, None)
print(d)
info = {'name':'zhangsan', 'age':18, 'sex':'male'}
res = info.setdefault('name', 'ZHANGSAN')
print(info)
#如果字典中有setdefault指定的key,那么不改该key对应的值,返回原的value
#如果字典中没有setdefault指定的key,那么新增一个key:value,返回新的value
info = {'name':'zhangsan', 'age':18, 'sex':'male'}
info.setdefault('height',180)
print(info)
info = {'age':18, 'sex':'male'}
v = info.setdefault('name','lisi')
print(v)
s = 'hello zhangsan zhangsan say hello lisi'
l = s.split()
print(l)
d = {}
for word in l:
if word not in d:
d[word] = 1
else:
e[word] += 1
s = 'hello zhangsan zhangsan say hello lisi'
l = s.split()
print(l)
d = {}
for word in l:
d[word] = l.count(word)
d.setfault(word, l.count(word))
print(d)
- 字典总结:
字典是一个可以存放多个值的数据类型,存放的值可以是任意类型,而key必须是不可变类型,通常是不可变类型中的字符串类型。字典是无序且可变的数据类型。
d = {'a':1, 'b':2}
print(id(d))
d['x'] = 123
print(id(d))
集合(set)
- 一、基本使用
1.用途:关系运算、去重
2.定义方式: {}内用逗号分隔开多个元素,每一个元素都是不可变类型。
3.集合内元素都必须是不可变类型,集合内元素无序,集合内元素不能重复
s = {1, 2, 'a'} # s = set({1, 2, 'a'})
print (type(s))
s= {1.1, 1, 'aa', (1, 2, 3), {'a':1}}
s= {1, 'a', 'hello', (1, 2, 3), 4}
for i in s:
print(i)#for循环取出来集合内元素
s = set('hello')
print(s)#集合有去重功能
若单纯用集合去重,需要注意的问题是:
1、去重的目标所包含的值都必须为不可变类型
2、去重的结果会打乱原有的顺序
nums = [1, 2, 3, 1, 2, 9, 3, 4, 6, 6, 6,]
s = set(nums)
nums = list(s)
print(nums)
- 二、常用操作以及内置方法
- 1、长度len
nums = {1, 11, 112, 21, 45, 8}
print(len(nums))
- 2、成员运算in和not in
nums = {1, 11, 112, 21, 45, 8}
print(15 in nums)
- 3、并集
nums = {1, 11, 112, 21, 45, 8}
nums1 = {5, 11 , 45, 8}
print(nums | nums1)
print(nums.union(nums1))
- 4、交集
nums = {1, 11, 112, 21, 45, 8}
nums1 = {5, 11 , 45, 8}
print(nums & nums1)
print(nums.intersection(nums1))
- 5、差集
nums = {1, 11, 112, 21, 45, 8}
nums1 = {5, 11 , 45, 8}
print(nums - nums1)
print(nums.difference(nums1) )
print(nums1 - nums)
print(nums1.difference(nums) )
- 6、对称差集
nums = {1, 11, 112, 21, 45, 8}
nums1 = {5, 11 , 45, 8}
print(nums ^ nums1)
print(nums.symmetric_difference(nums1) )
print(nums1 ^ nums)
- 7、判断是否相等
nums = {1, 11, 112, 21, 45, 8}
nums1 = {5, 11 , 45, 8}
print(num1 == nums1)
- 8、父集
nums = {1, 11, 112, 21, 45, 8}
nums1 = {5, 11 , 45, 8}
print(nums > nums1)
print(nums.issuperset(nums1))
print(nums1 > nums)
print(nums1.issuperser(nums))
- 9、子集
s1={1,2,3,4,5}
s2={3,4,5} print(s1 > s2)
print(s1.issubset(s2))
print(s2 > s1)
print(s2.issubset(s1))
- 10、其他方法
s1={1,2,3,4,5}
s1.add(6)#添加一个新元素
s1.update({4, 7, 9,})#添加集合内没有的元素,集合有去重功能
res = s1.pop
print(res)#随机删除一个元素
s1={1,2,3,4,5}
res = s1.remove(4)
print(s1)#删除指定元素,有返回值
s1={1,2,3,4,5}
s1.discard(8)
print(s1)#删除一个不存在的值,但不会报错
s1={1,2,3,4,5}
s2={6,7,8}
print(s1.isdisjoint(s2))#若两集合无交集,则返回真
集合总结:集合可以存一个或多个值,且都为不可变类型,是无序的数据类型,集合是可变类型。