python02---基础数据类型

一. 什么是数据类型

我们人类可以很容易的分清数字与字符的区别,但是计算机并不能呀,计算机虽然很强大,但从某种角度上看又很傻,除非你明确的告诉它,1是数字,“汉”是文字,否则它是分不清1和‘汉’的区别的,因此,在每个编程语言里都会有一个叫数据类型的东东,其实就是对常用的各种数据类型进行了明确的划分,你想让计算机进行数值运算,你就传数字给它,你想让他处理文字,就传字符串类型给他。

Python中常用的数据类型有多种,如下:

整数(int) ,字符串(str),布尔值(bool),列表(list),元组(tuple),字典(dict),集合(set).

1.1 可变数据类型和不可变数据类型

1.1.1 可变数据类型

列表 list,字典 dict,集合 set;
不可hash

1.1.2 不可变数据类型

不可更改的数据类型(可hash),元祖,bool,数字,str

二. 基础数据类型---数字

2.1 整型(int)

跟C语言不同,Python的长整数没有指定位宽,即:Python没有限制长整数数值的大小,但实际上由于机器内存有限,我们使用的长整数数值不可能无限大。
注意,自从Python2.2起,如果整数发生溢出,Python会自动将整数数据转换为长整数,所以如今在长整数数据后面不加字母L也不会导致严重后果了。
注意:在Python3里不再有long类型了,全都是int

除了int和long之外, 其实还有float浮点型, 复数型,但今天先不讲啦

2.1.1 bit_length()

数字主要是用于计算用的,使用方法并不是很多,就记住一种就可以:

#bit_length() 当十进制用二进制表示时,最少使用的位数
v = 11
data = v.bit_length()
print(data)

2.2 浮点型(float)

三. 布尔值 bool

布尔类型很简单,就两个值 ,一个True(真),一个False(假), 主要用记逻辑判断

但其实你们并不明白对么? let me explain, 我现在有2个值 , a=3, b=5 , 我说a>b你说成立么? 我们当然知道不成立,但问题是计算机怎么去描述这成不成立呢?或者说a< b是成立,计算机怎么描述这是成立呢?
没错,答案就是,用布尔类型

布尔值就两种:True,False。就是反应条件的正确与否。

真   1   True。
假   0   False。

字符串
'' 空为 False,非空位True

四. 字符串 str

在Python中,加了引号的字符都被认为是字符串!

name = "Alex Li" #双引号
age = "22" #只要加引号就是字符串
age2 = 22 #int msg = '''My name is taibai, I am 22 years old!''' #我擦,3个引号也可以 hometown = 'ShanDong' #单引号也可以

那单引号、双引号、多引号有什么区别呢?

让我大声告诉你,单双引号木有任何区别,只有下面这种情况 你需要考虑单双的配合

msg = "My name is Alex , I'm 22 years old!"

多引号什么作用呢?作用就是多行字符串必须用多引号

msg = '''
今天我想写首小诗,
歌颂我的同桌,
你看他那乌黑的短发,
好像一只炸毛鸡。
'''
print(msg)

字符串拼接

数字可以进行加减乘除等运算,字符串呢?让我大声告诉你,也能?what ?是的,但只能进行"相加"和"相乘"运算。

>>> name
'Alex Li'
>>> age
'22'
>>>
>>> name + age #相加其实就是简单拼接
'Alex Li22'
>>>
>>> name * 10 #相乘其实就是复制自己多少次,再拼接在一起
'Alex LiAlex LiAlex LiAlex LiAlex LiAlex LiAlex LiAlex LiAlex LiAlex Li'

注意,字符串的拼接只能是双方都是字符串,不能跟数字或其它类型拼接

>>> type(name),type(age2)
(<type 'str'>, <type 'int'>)
>>>
>>> name
'Alex Li'
>>> age2
>>> name + age2
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: cannot concatenate 'str' and 'int' objects #错误提示数字 和 字符 不能拼接

4.1 索引

索引即下标,就是字符串组成的元素从第一个开始,初始索引为0以此类推。

# 索引从0开始
s='ABCDEFGHIJK' # 索引,每一次检索都是创建了一个新的字符串,原字符串不发生变化
print(s[0]) # 顺序取
print(s[-1]) # 逆序取

4.2 切片

切片就是通过索引(索引:索引:步长)截取字符串的一段,形成新的字符串(原则就是顾头不顾腚)。

# 切片 ABCD , 顾头不顾尾,尾+1
print(s[0:3])
print(s[0:4]) # s[首:尾]
print(s,s[:],s[0:]) # 全量的三种方法 # 取 A,C,F
print(s[0:5:2]) # s[首:尾:步长] # 逆序取
print(s[-1::-1]) # s[首:尾:步长]
print(s[::-1])

取全量

# 正向取
print(s,s[:],s[0:]) # 全量的三种方法 # 逆序取
print(s[-1::-1]) # s[首:尾:步长]
print(s[::-1])

4.3 大小写转换

4.3.1 upper() 转大写

s = 'superVi teacher2 help*you'
# 大小写转换,对数字没有影响
# 使用场景:验证码
print(s.upper()) # 转 大写

4.3.2 lower() 转小写

s = 'superVi teacher2 help*you'
print(s.lower()) # 转 小写

4.3.3 capitalize() 仅首字母大写

s = 'superVi teacher2 help*you'
s2 = 'sup\terVi teacher\t2 he\tlp*you' print(s.capitalize()) # 仅首字母大写 Supervi

4.3.4 swapcase() 大小写反转

s = 'superVi teacher2 help*you'
print(s.swapcase()) # 大小写反转 SUPERvI

4.4 排版

4.4.1 center() 居中

在特定宽度中,居中输出字符串,空余部分指定字符填充

s = 'superVi teacher2 help*you'

# 内容居中,长度,空白处填充
print(s.center(50,'@')) # center(长度,'填充物') 默认为空格
print(s.center(5,'@')) # 如长度不够,输出原字符,排版失败

4.4.2 expandtabs() 特定宽度

# 制表符宽度,补齐
s2 = 'sup\terVi teacher\t2 he\tlp*you'
print(s2.expandtabs()) # 默认将转换,\t = 8 位(
print(s2.expandtabs(3)) # 如果字符等于8位,则不作转换,不满足8位的补足

4.4.3 format() 格式化输出

#format的三种玩法 格式化输出
res='{} {} {}'.format('egon',18,'male')
res='{1} {0} {1}'.format('egon',18,'male')
res='{name} {age} {sex}'.format(sex='male',name='egon',age=18)

4.4.4 title() 单词以大写字母开头

s = 'superVi teacher2 help*you'
print(s.title()) # 仅单词首字母大写,间隔符需特殊字符(包含数字)

4.5 条件检索

4.5.1 startswith() / endswith() 以...开头/结尾

以...开头,结尾

print(s.startswith('s'))   # 判断是否已...开头,返回bool值
print(s.startswith('u',2,4)) # 判断切片位置,是否以...开头
print(s.endswith(''))

4.5.2 find() / index 检索元素位置

检索元素位置

# 是否包含指定字符串,返回索引
print(s.find('u')) # 通过元素,找索引下标(第一个),找不到返回-1
print(s.find('M')) # 找不到返回-1 # 检索元素位置,找不到报错
print(s.index('u')) # 通过元素,找索引下标(第一关)
# print(s.index('M')) # 找不到,报错

4.5.3 由...组成

元素是否由什么组成

#####is系列
name='taibai123'
print(name.isalnum()) #字符串由字母或数字组成
print(name.isalpha()) #字符串只由字母组成
print(name.isdigit()) #字符串只由数字组成

4.6 分割 / 拆分 / 替换

4.6.1 split() 文本分割 (字符串转换列表)

字符串分割,以什么分割,最终形成一个列表此列表不含有这个分割的元素,

默认分割字符为空格或多个空格,其它字符不可以

# 拆分,分割文本 ,split  ; str --> listPython
s = 'superVi teacher2 help*you'
s1 = ' superVi teacher2 help*you' print(s.split(' ')) # ['superVi', 'teacher2', 'help*you']
print(s.split('*')) # ['superVi teacher2 help', 'you']
print(s1.split(' ')) # ['', 'superVi', 'teacher2', 'help*you']

返回值需要有一个列表来接收

4.6.2 replace() 替换

把...替换为...替换次数

#replace
name='alex say :i have one tesla,my name is alex'
print(name.replace('alex','SB',1))

4.7 其它

4.7.1 count() 统计指定元素出现的次数

#数字符串中的元素出现的个数。
ret3 = a1.count("a",0,4) # 可切片
print(ret3)

4.7.2 strip() 按序消除字符串

#strip
name='*barry**'
print(name.strip('*'))
print(name.lstrip('*'))
print(name.rstrip('*'))

4.8 随手写了个bug

str1 = input('我要判断,你输入数次的个数,多个数字相连判做一个数字! >>>') # w3t4h5u7i8g445fdgt3

for i in str1:
if i.isalpha():
str1=str1.replace(i,' ') print(str1.split())

五. 列表 list

列表是python中的基础数据类型之一,其他语言中也有类似于列表的数据类型,比如js中叫数组,他是以[]括起来,每个元素以逗号隔开,而且他里面可以存放各种数据类型比如:

li = ['alex',123,True,(1,2,3,'wusir'),[1,2,3,'小明',],{'name':'alex'}]

列表相比于字符串,不仅可以储存不同的数据类型,而且可以储存大量数据,32位python的限制是 536870912 个元素,64位python的限制是 1152921504606846975 个元素。而且列表是有序的,有索引值,可切片,方便取值。

5.1 列表的索引和切片

# 取单个元素的时候,这个元素是什么类型,取出来就是什么类型
# 切片操作时,取到的为列表类型 li = ['alex',123,True,(1,2,3,'wusir'),[1,2,3,'小明',],{'name':'alex'}] print('列表:',li,'\n')
print('第一个元素',li[0])
print('前3个元素',li[0:4])

5.2 列表操作---增

5.2.1 append() 尾部追加

没有返回值,None

li = ['1',2,[3,4]]
print(li) # ['1', 2, [3, 4]] li.append('end')
print(li) # ['1', 2, [3, 4], 'end']

示例:追加花名册,

while 1:
username = input("输入名字,ok 退出:>>> ")
if username.lower().replace(' ','')!='ok':
li.append(username)
continue
break
print(li) while 1:
username = input("输入名字,ok 退出:>>> ")
if username.lower().replace(' ','')=='ok':break
li.append(username)
print(li)

5.2.2 insert 指定位置插入

li = [1,2,3,4]

li.insert(1,'long')
print(li)

5.2.3 extend 可迭代对象

将可迭代对象的元素,依次追加至最后

  • 字符串:转化为单字符进行追加
  • 列表:将各元素依次追加
# 原字符串
bjx = ["zhao"]
bjx.extend('qian')
print(bjx) # 追加列表
bjx.extend(['qian','sun'])
print(bjx)

5.3 列表操作---删

  • 按元素   ---  remove()
  • 按索引   ---  pop()
  • 清空   ---   clear() / del

5.3.1 pop() 根据索引删除

返回索引对应的元素,并在原列表中删除,找到返回元素,找不到报错

li = [1, 2, 3, 4]
li.pop(1)
print(li) # [1, 3, 4] # 为空时,删除最后一位

5.3.2 remove 按照元素删除

按照元素去删,只删除一个,顺序从左向右,找到返回None,找不到返回错误

# remove
li = [1, 2, 3,4,3]
li.remove(3)
print(li) # [1, 2, 4] # li.remove() # 报错

5.3.3 clear() 清空列表

清除元素,保留列表指针

li = [1, 2, 3,4,3]
li.clear()
print(li) # []

5.3.4 del 删除列表

删除列表,释放内存空间(删除指针)

li = [1, 2, 3,4,3]
del li
print(li) # NameError: name 'li' is not defined

切片去删

li = [1, 2, 3,4,3]

del li[2:] # [1, 2]
print(li)

5.4 列表操作---改

5.4.1 根据索引去改

li = [1, 2, 3, 4, 5]
li[0]='yi'
print(li)

5.4.2 根据切片去改

用切片的方式修改列表,如果值是可迭代对象,则在切片位置依次插入可迭代对象的每一个元素

li = [1, 2, 3, 4, 5]
li[0:2]='一二' # 等值替换
print(li) # ['一', '二', 3, 4, 5] li[0:2]='一' # 切片个数被一个元素所替代
print(li) # ['一', 3, 4, 5] li[0:2]='一二san' # 所替换元素的个数大于切片的个数
print(li) # ['一', '二', 's', 'a', 'n', 3, 4, 5]

切片修改不可迭代对象

li = [1, 2, 3, 4, 5]
li[0:2]=2,2
print(li) # ['一', '二', 's', 'a', 'n', 3, 4, 5] li = [1, 2, 3, 4, 5]
li[0:2]=2 # 当不是可迭代对象时,被替换的数量要不少于切片元素数量
print(li) # ['一', '二', 's', 'a', 'n', 3, 4, 5]

情景展示

Traceback (most recent call last):
['yi', 2, 3, 4, 5]
File "D:/workSpace/python/day04/1.list.py", line 94, in <module>
li[0:2]=2
TypeError: can only assign an iterable

5.5 列表的操作---查

5.5.1 查看整个列表

用 for 循环

li = [1, 2, 3, 4, 5]

for i in li:
print(i)

5.5.2 根据切片查看

li = [1, 2, 3, 4, 5]
print(li[0:3])

5.6 公共方法

5.6.1 len 长度

li = [1, 2, 3, 4, 5,3,3,3]
print(len(li))

5.6.2 count  次数统计

li = [1, 2, 3, 4, 5,3,3,3]
print(li.count(3))

5.6.3 index 查找索引

找不到报错

li = [1, 2, 3, 4, 5,3,3,3]
print(li.index(3)) print(li.index(33)) # ValueError: 33 is not in list

5.7 排序

5.7.1 sort(reverse=True) 正向排序

li = [1, 2, 3, 4, 5,3,3,3]
li.sort()
print(li)

5.7.2 sort 逆向排序

li = [1, 2, 3, 4, 5,3,3,3]

li.sort(reverse=True)
print(li)

5.7.3 reverse 顺序反转

li = [1, 2, 3, 4, 5, 3, 3, 3]

li.reverse()
print(li)

5.8. 列表的嵌套

列表里面嵌套列表,就是列表的嵌套了

5.8.1 修改元素

列表是由一个个多元化的元素组成的,在修改的时候,我们可以通过取这个列表的元素,根据元素的类型,来进行相应的操作

li = ['xiaobai','苍劲空','乔延难',['name','age','sex']]
print(li[1][1]) li[1]=li[1].replace('劲','井')
print(li)

5.9 其它

5.9.1 join(iterable) 可迭代对象转换成字符串

根据提供的字符串,来连接可迭代对象,返回字符串

s=xiaobai
'_'.join(s) # x_i_a_o_b_a_i

示例:列表和字符串互转

li = ["zhao",'qian','sun','li']
li2 = ["zhao",'qian','sun','li',['aa','bb']] # 这个是不可以用 join 进行拼接的
print(li) s = '_'.join(li)
print(s) l2 =s.split('_')
print(l2)

5.9.2 range(start,end,步长)

可以看作一个列表

# start <= i < end
for i in range(1,20):
print(i) for i in range(20): # 从 0 开始写,可以不写0
print(i) for i in range(0,20,2): # 步长,开头不能省略
print(i) for i in range(10,0,-2): # 逆序取步长
print(i) for i in range(0,20,-1): # 错误示例,什么也不输出
print(i)

5.9.3 多级列表元素的遍历

li = ["zhao",'qian','sun','li',['aa','bb'],1,2,[2,3]]

for i in li:
if type(i)==list:
for j in i:
print(j)
continue
print(i)

七. 元组 tuple

元组被称为只读列表,即数据可以被查询,但不能被修改,所以,字符串的切片操作同样适用于元组。例:(1,2,3)("a","b","c")

  • 可循环,可查询,可切片;
  • 元祖的元素类型是不能发生变化的,元祖元素的子元素是可以修改的
  • 元组里面不加逗号,切只有一个元素,该是什么类型,就是什么类型

7.1 修改元素的子元素

tu = (1,2,3,'xiaobai',[2,3,4,'yisheng','happy'])

# 遍历元祖元素
for i in tu:
print(i) # 取构成元祖元素的子元素
print(tu[4][3]) # 修改元祖元素的子元素
tu[4][3]=tu[4][3].upper()
print(tu[4][3])

7.2 元组的一级元素是不可改变的

八. 字典 dict

字典是python中唯一的映射类型,采用键值对(key-value)的形式存储数据。python对key进行哈希函数运算,根据计算的结果决定value的存储地址,所以字典是无序存储的key必须是可哈希的。可哈希表示key必须是不可变类型,如:数字、字符串、元组、bool值。
字典(dictionary)是除列表以外python之中最灵活的内置数据结构类型。列表是有序的对象结合,字典是无序的对象集合**。两者之间的区别在于:字典当中的元素是通过键来存取的,而不是通过偏移存取。

字典的优点:寻找速度快,二分查找法去查询,
如何初始化一个字典?

特点:

  • 储存大量的关系型数据
  • 无序的(3.5 / 3.6)之前,
  • 查询速度非常快

8.1 如何定义字典?

字典的构成需要有三个元素,字典名字,键值对(key,value),键值对可为空

dicName={
'key':['字符串','可以当 key'],
2:'数字类型,可以当 key',
(1,2,3):['元祖','可以当 key'],
True:'bool 值,也可一当key'
}
dicTest2={}
print(dicName,dicTest2)

结果

# {'key': ['字符串', '可以当 key'], 2: '数字类型,可以当 key', (1, 2, 3): ['元祖', '可以当 key'], True: 'bool 值,也可一当key'} {}

8.2 字典的增加

8.2.1 dic[haha]='xiao;

有的覆盖,没有的添加
根据key值,直接修改,没有的增加,有的修改 value

dicAdd= {'age': 18, 'name': 'xiaobaiyisheng'}

dicAdd['sex']='M'     # 没有增加
dicAdd['name']='Li' # 有的更改 print(dicAdd)

8.2.2 setdefault(key,value)

没有的添加,有的不做修改

dicAdd= {'age': 18, 'name': 'xiaobaiyisheng'}

dicAdd.setdefault('妻子')        # '妻子': None 不设置value,None填充
dicAdd.setdefault('兴趣','HGN') # 添加,没有直接加上 dicAdd.setdefault('age',100) # 直接修改生死簿,走好了您
print(dicAdd) # 没有拿到判官笔,修改失败

8.3 字典的删除

8.3.1 pop(key,value),有返回值

找到key,删除;找不到,返回错误,如果定义返回值,则返回定义的值

dicAdd= {'age': 18, 'name': 'xiaobaiyisheng'}

print(dicAdd.pop('name'))             # 找到要删除的key,删除
print(dicAdd.pop('name1')) # 找不到要删除的key,报错 print(dicAdd.pop('name','meiyou')) # 找到要删除的key,返回key
print(dicAdd.pop('name1','meiyou')) # 找不到要删除的key,返回自定的value print(dicAdd)

8.3.2 pop.item()

自后向前删,有返回值,无参; 老版本是随机删除,返回被删除的键值组成的元组

dicAdd= {'age': 18, 'name': 'xiaobaiyisheng'}
print(dicAdd.popitem()) # 被删除内容,('name', 'xiaobaiyisheng')
print(dicAdd.popitem()) # 被删除内容,('age', 18)
print(dicAdd.popitem()) # popitem(): dictionary is empty # 不要尝试添加参数,这是不理智的
print(dicAdd.popitem('age')) # TypeError: popitem() takes no arguments (1 given)

8.3.3 clear()

8.3.4 del

删除,无返回值

dicAdd= {'age': 18, 'name': 'xiaobaiyisheng'}
del dicAdd
del dicAdd['age']

8.4 改

8.4.1 覆盖

8.4.2 update()

值不同的进行更新,key没有的进行添加

dic = {"name":"xiaobai","age":18,"sex":"man"}
dic2 = {"name":"xiaobaiyisheng","weight":75} dic.update(dic2) # dic 来保存 dic2的更新
print(dic,dic2)

8.5 查

8.5.1 打印字典

dic = {"name":"xiaobai","age":18,"sex":"man"}

print(dic.keys(),type(dic.keys()))       # key 组成的 列表
print(dic.values(),type(dic.values())) # value 组成的列表
print(dic.items(),type(dic.items())) # key和值组成的,元祖形式组成的列表

打印键值

dic = {"name":"xiaobai","age":18,"sex":"man"}
for i in dic.items():
print(i) for k,v in dic.items():
print(k,v)

8.5.2 get() 根据key找

根据key取值,默认取不到返回错误,可以指定返回值

dic = {"name":"xiaobai","age":18,"sex":"man"}

dic.get('name1')       # error
print(dic.get('name1',1))
print(dic.get('name',1))
print(dic)

8.6 字典的嵌套

示例列表

dic = {
'name': ['zhangsan', 'lisi', 'wangwu'],
'11': {
'time': '1213',
'learn_money': 19800,
'addr': 'CBD'
},
'age': 21
}

8.6.1 添加

#  name 列添加 zhaoliu
print(dic['name'].append('zhaoliu'))
print(dic) # 在 11 的字典 里,添加 一个键值对
dic['11'].setdefault('女生',6)
dic['11']['男生']=7
print(dic)

8.6.2 修改

# 修改 age 30
dic['age'] = 210 # lisi 大写
dic['name'][1]=dic['name'][1].upper()
print(dic)

九. 集合

集合是无序的,不重复的数据集合,它里面的元素是可哈希的(不可变类型),但是集合本身是不可哈希(所以集合做不了字典的键)的。
以下是集合最重要的两点:

  • 去重,把一个列表变成集合,就自动去重了。
  • 关系测试,测试两组数据之前的交集、差集、并集等关系。

9.1 集合的声明

set1 = set({1,2,3,4,'1',(1,2,3,),True,'AAA','AAA',False,3})
print(set1)
# {'1', 1, 2, 3, 4, False, (1, 2, 3)}
# 并没有打印 True
# 集合是无序的
# 集合是不重复的

尝试在集合中包含可变类型数据

# set2={1,2,3,[2,3],{'name':123}}
# print(set2) # TypeError: unhashable type: 'list' set3={1,2,3,{'name':123}}
print(set3) # TypeError: unhashable type: 'dict'

9.2 增

9.2.1 add()

set1 ={'ZHAO','QIAN','SUN','LI'}
set1.add('zhou')
print(set1)

9.2.2 update 迭代添加

传递一个可迭代对象的时候,会依次添加的

set1 ={'ZHAO','QIAN','SUN','LI'}

set1.update('123')
print(set1) # {'2', 'zhou', 'SUN', '3', 'LI', 'QIAN', 'ZHAO', '1'}
set1.update([1,2,'33'])
print(set1) # {1, 2, 'SUN', 'QIAN', '33', 'LI', 'ZHAO'}

9.3 删

9.3.1 pop() 随机删除

set1 ={'ZHAO','QIAN','SUN','LI'}
set1.pop()
print(set1) # 每次执行,删除的结果都不一样

9.3.2 clear() 清空

简单的讲,就是值没有了

set1 ={'ZHAO','QIAN','SUN','LI'}
# set1.pop()
# print(set1.pop())
set1.clear()

9.3.3 del set 删除

del set1
# 删了就没有了

9.3.4 查 循环便利

set1 = set({1,2,3,4,'1',(1,2,3,),True,'AAA','AAA',False,3})
for i in set1:
print(i)

9.4 交集  (&  或者 intersection)

A 有,B也有

SET1 = {1,2,3,4,5}
SET2 = {4,5,6,7,8} print(SET1 & SET2)
print(SET1.intersection(SET2)) # {4, 5}

9.5 并集 (| 或者 union)

A 和 B 共有

set1 = {1,2,3,4,5}
set2 = {4,5,6,7,8} print(set1 | set2)
print(set1.union(set2)) # {1, 2, 3, 4, 5, 6, 7, 8}

9.6 差集 (- 或者 difference)

差集 A 有 B 没有

set1 = {1,2,3,4,5}
set2 = {4,5,6,7,8} # 差集 A 有 B 没有
print(set1-set2)
print(set1.difference(set2)) # {1, 2, 3}

9.7 反交集 (^ 或者 symmetric_difference)

A 和 B 相互独立的元素的集合

set1 = {1,2,3,4,5}
set2 = {4,5,6,7,8} #(^ 或者 symmetric_difference)
# A 和 B 相互独立的元素的集合
print(set1 ^ set2)
print(set1.symmetric_difference(set2)) # {1, 2, 3, 6, 7, 8}

9.8 子集与超集

set1 = {1,2,3}
set2 = {1,2,3,4,5,6} # 子集 <
print(set1 < set2)
print(set1.issubset(set2)) # 超集 >
print(set2 > set1)
print(set2.issuperset(set1))

9.9 小例子

9.9.1 列表去重

li = [1,2,33,33,2,1,4,5,6,6]

print(list(set(li)))

9.10 forzenset() 不可变集合

不可变集合

s = frozenset('barry')
print(s,type(s)) # frozenset({'a', 'y', 'b', 'r'}) <class 'frozenset'>

十. 基础数据类型总结

10.1 按存储空间的占用分(从低到高)

数字
字符串
集合:无序,即无序存索引相关信息
元组:有序,需要存索引相关信息,不可变
列表:有序,需要存索引相关信息,可变,需要处理数据的增删改
字典:无序,需要存key与value映射的相关信息,可变,需要处理数据的增删改

10.2 按可变不可变区分

可变 列表,字符串
不可变 数字,字符串,元组,布尔值

10.3 按访问顺序区分

直接访问 数字
顺序访问(序列类型) 字符串,列表,元组
key值访问(映射类型) 字典

十一. 其它

11.1 for循环

用户按照顺序循环可迭代对象的内容

msg='人之初,行本事,性相近,习相远'

for i in msg:
print(i) msg='人之初,行本事,性相近,习相远' li = msg.split(',') for i in li:
print(i) dic={
'xing':['zhao','qian','sun','li'],
'name':[1,2,3,4]
} for k,v in dic.items():
print(k,v)

11.2 enumerate:枚举

对于一个可迭代的(iterable)/ 可遍历的对象(如列表、字符串),enumerate将其组成一个索引序列,利用它可以同时获得索引和值

msg=['人之初','行本事','性相近','习相远']

for i in enumerate (msg):
print(i) for index,name in enumerate(msg,1):
print(index,name) for index,name in enumerate(msg,100):
print(index,name)

11.3 range

指定反问,生成指定数字

for i in range(1,10):
print(i) for i in range(1,10,2): # 步长
print(i) for i in range(10,1,-2): # 反向步长
print(i)

python02---基础数据类型的更多相关文章

  1. [.net 面向对象编程基础] (3) 基础中的基础——数据类型

    [.net 面向对象编程基础] (3) 基础中的基础——数据类型 关于数据类型,这是基础中的基础. 基础..基础..基础.基本功必须要扎实. 首先,从使用电脑开始,再到编程,电脑要存储数据,就要按类型 ...

  2. TypeScript学习指南第一章--基础数据类型(Basic Types)

    基础数据类型(Basic Types) 为了搭建应用程序,我们需要使用一些基础数据类型比如:numbers,strings,structures,boolean等等. 在TypeScript中除了Ja ...

  3. 【Swift】学习笔记(一)——熟知 基础数据类型,编码风格,元组,主张

    自从苹果宣布swift之后,我一直想了解,他一直没有能够把它的正式学习,从今天开始,我会用我的博客来驱动swift得知,据我们了解还快. 1.定义变量和常量 var  定义变量,let定义常量. 比如 ...

  4. 二、Windows基础数据类型

    六.Windows Data Types 简介: 6.1.这些数据类型都是C语言数据类型的再次的进行包装. 6.2.因为考虑到如果使用的是C中的基础数据类型可能无法表示,想表示的精准的含义. 6.3. ...

  5. java基础数据类型包装类

    */ .hljs { display: block; overflow-x: auto; padding: 0.5em; color: #333; background: #f8f8f8; } .hl ...

  6. java.lang基础数据类型boolean、char、byte、short、int、long、float、double (JDK1.8)

    java.lang.Boolean public static int hashCode(boolean value) { return value ? 1231 : 1237; } JDK 1.8新 ...

  7. Python基础数据类型之列表和元组

    一.列表   list 列表是python中的基础数据类型之一,其他语言中也有类似于列表的数据类型,比如js中叫数组,他是以[]括起来,每个元素以逗号隔开,而且他里面可以存放各种数据类型比如: li ...

  8. Python基础数据类型之字典

      基础数据类型之字典 ps:数据类型划分:可变数据类型和不可变数据类型. 不可变数据类型:元组(tupe).布尔值(bool).整数型(int).字符串(str).不可变数据类型也称为可哈希. 可变 ...

  9. Python基础数据类型之集合以及其他和深浅copy

    一.基础数据类型汇总补充 list  在循环一个列表时,最好不要删除列表中的元素,这样会使索引发生改变,从而报错(可以从后向前循环删除,这样不会改变未删元素的索引). 错误示范: lis = [,,, ...

  10. python基础二(基础数据类型)

    一. 引子 1. 什么是数据 x=10,10是我们要存储的数据 2. 为何数据要分不同的类型 数据是用来表示状态的,不同的状态就应该用不同的类型的数据去表示 3.数据类型 数字 字符串 列表 元组 字 ...

随机推荐

  1. android: 结合BottomNavigationView、ViewPager和Fragment 实现左右滑动的效果

    主界面:MainActivity package com.yongdaimi.android.androidapitest; import android.os.Bundle; import andr ...

  2. Puppeteer最大化显示,分辨率自适应

    Puppeteer自适应分辨率,可以将defaultViewport设为null, 启动的时候还是半屏显示,点击最大化按钮,可以最大化显示. 这样分辨率能够自适应操作系统. 具体可看:https:// ...

  3. Please enable using preview .net core sdks

    工具=>选项=>环境=>预览功能=>使用.net core sdk的预览

  4. (转载) AutoML 与轻量模型大列表

    作者:guan-yuan 项目地址:awesome-AutoML-and-Lightweight-Models 博客地址:http://www.lib4dev.in/info/guan-yuan/aw ...

  5. Kafka在zookeeper中存储结构和查看方式

    Zookeeper 主要用来跟踪Kafka 集群中的节点状态, 以及Kafka Topic, message 等等其他信息. 同时, Kafka 依赖于Zookeeper, 没有Zookeeper 是 ...

  6. maven项目打包跳过单元测试

    在pom.xml中添加一下代码: <plugin> <groupId>org.apache.maven.plugins</groupId> <artifact ...

  7. MySQL之表日志管理

    MySQL日志管理 mysql日志(默认存放在datadir): 同大多数关系型数据库一样,日志文件是MySQL数据库的重要组成部分.MySQL有几种不同的日志文件,通常包括错误日志文件,二进制日志, ...

  8. 最新 梆梆安全java校招面经 (含整理过的面试题大全)

    从6月到10月,经过4个月努力和坚持,自己有幸拿到了网易雷火.京东.去哪儿.梆梆安全等10家互联网公司的校招Offer,因为某些自身原因最终选择了梆梆安全.6.7月主要是做系统复习.项目复盘.Leet ...

  9. windwos 安装 vue-cli

    安装vue-cli 安装之前我们需要先安装node.js以及包管理工具npm,有兴趣的可以安装nvm版本管理工具 地址:https://www.cnblogs.com/lph970417/p/1184 ...

  10. Qt deletelater函数分析(1)

               生活的全部意义在于无穷地探索尚未知道的东西,在于不断地增加更多的知识.--左拉 该函数是QObject类的函数:                             ---- ...