python基础数据类型

什么是数据类型？

每个编程语言里都会有一个叫数据类型的东东，其实就是对常用的各种数据类型进行了明确的划分，你想让计算机进行数值运算，你就传数字给它，你想让他处理文字，就传字符串类型给他。Python中常用的数据类型有多种，如下：

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

•  int。数字：主要用于运算。1 ，2,3...
•  bool。判断真假：True, False.
•  str。简单少量的储存数据，并进行相应的操作。name = 'alex',
•  tuple。只读，不能更改。(1,'alex') 
•  list：大量有序数据，[1,'ses',True,[1,2,3],{'name':'jinxin'}]
•  dict：大量数据，且是关联性比较强的数据  {'name':'jinxin','age':18,'name_list':['张三'，'李四']}

十进制整数转换为二进制整数采用"除2取余，逆序排列"法。具体做法是：用2整除十进制整数，可以得到一个商和余数；再用2去除商，又会得到一个商和余数，如此进行，直到商为小于1时为止，然后把先得到的余数作为二进制数的低位有效位，后得到的余数作为二进制数的高位有效位，依次排列起来。

十进制小数转换成二进制小数采用"乘2取整，顺序排列"法。具体做法是：用2乘十进制小数，可以得到积，将积的整数部分取出，再用2乘余下的小数部分，又得到一个积，再将积的整数部分取出，如此进行，直到积中的小数部分为零，此时0或1为二进制的最后一位。或者达到所要求的精度为止。

二进制转化成十进制: 

    要从右到左用二进制的每个数去乘以2的相应次方,小数点后则是从左往右

    例如：二进制数1101.01转化成十进制

    1101.01（2）=1*20+0*21+1*22+1*23 +0*2-1+1*2-2=1+0+4+8+0+0.25=13.25（10）

    所以总结起来通用公式为：

    abcd.efg(2)=d*20+c*21+b*22+a*23+e*2-1+f*2-2+g*2-3（10）

或者是：

    把二进制数首先写成加权系数展开式，然后按十进制加法规则求和。这种做法称为"按权相加"法。

    此时，1101=8+4+0+1=13

    再比如：二进制数100011转成十进制数可以看作这样：

    数字中共有三个1 即第一位一个，第五位一个，第六位一个，然后对应十进制数即2的0次方+2的1次方+2的5次方， 即

    100011=32+0+0+0+2+1=35

 因为数字主要是用于计算，所以针对于数字可以使用的方法除了那些运算之外，没有什么经常会用的方法，python给咱们提供了一种方法：bit_length()就是帮助你快速的计算整数在内存中占用的二进制码的长度.

num = 10
print(num.bit_length())  # 当十进制用二进制表示时，最少使用的位数

# 运行结果: 4

 

2.布尔值

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

真   1   True。

假   0   False。  

这里补充一下int str bool 三者数据类型之间的转换。

 1 # int ---> bool
 2 i = 100
 3 print(bool(i))  # True  # 非零即True
 4 i1 = 0
 5 print(bool(i1))  # False 零即False
 6 
 7 # bool ---> int
 8 t = True
 9 print(int(t))  # 1  True --> 1
10 t = False
11 print(int(t))  # 0  False --> 0
12 
13 # int ---> str
14 i1 = 100
15 print(str(i1))  # '100'
16 
17 # str ---> int  # 全部由数字组成的字符串才可以转化成数字
18 s1 = '90'
19 print(int(s1))  # 90
20 
21 # str ---> bool
22 s1 = '太白'
23 s2 = ''
24 print(bool(s1))  # True 非空即True
25 print(bool(s2))  # False
26 # bool ---> str
27 t1 = True
28 print(str(True))  # 'True'

View Code

 

2.1字符串。

Python中凡是用引号引起来的数据可以称为字符串类型，组成字符串的每个元素称之为字符，将这些字符一个一个连接起来，然后在用引号起来就是字符串。

组成字符串的字符从左至右，依次排列，他们都是有顺序的，就好比是部队的队列，从左至右依次报号(从零开始) ：0,1,2,3....

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

a = 'ABCDEFGHIJK'
print(a[0])
print(a[3])
print(a[5])
print(a[7])

2.2.切片就是通过索引（索引：索引：步长）截取字符串的一段，形成新的字符串（原则就是顾头不顾腚）。

a = 'ABCDEFGHIJK'
print(a[0:3])  # print(a[:3]) 从开头开始取0可以默认不写
print(a[2:5])
print(a[:]) #默认到最后
print(a[:-1]) # -1 是列表中最后一个元素的索引，但是要满足顾头不顾腚的原则，所以取不到K元素
print(a[:5:2]) #加步长
print(a[-1:-5:-2]) #反向加步长

2.3.2、字符串常用方法。

字符串除了可以用切片（步长）之外，还有一些其他的操作方法。

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

a4 = "dkfjdkfasf54"
#startswith 判断是否以...开头
#endswith 判断是否以...结尾
# ret4 = a4.endswith('jdk',3,6)  # 顾头不顾腚
# print(ret4)  # 返回的是布尔值
# ret5 = a4.startswith("kfj",1,4)
# print(ret5)

#split 以什么分割，最终形成一个列表此列表不含有这个分割的元素。
# ret9 = 'title,Tilte,atre,'.split('t')
# print(ret9)
# ret91 = 'title,Tilte,atre,'.rsplit('t',1)
# print(ret91)

#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)

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

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

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


#############下面这些方法在数据类型补充时会讲到，现在不讲####################
#寻找字符串中的元素是否存在
# ret6 = a4.find("fjdk",1,6)
# print(ret6)  # 返回的找到的元素的索引，如果找不到返回-1

# ret61 = a4.index("fjdk",4,6)
# print(ret61) # 返回的找到的元素的索引，找不到报错。

#captalize,swapcase,title
print(name.capitalize()) #首字母大写
print(name.swapcase()) #大小写翻转
msg='taibai say hi'
print(msg.title()) #每个单词的首字母大写

# 内同居中，总长度，空白处填充
ret2 = a1.center(20,"*")
print(ret2)

View Code

#startswith 判断是否以...开头
#endswith 判断是否以...结尾

#split 以什么分割，最终形成一个列表此列表不含有这个分割的元素。

#format的三种玩法 格式化输出

#strip          #replace         #####is系列

name='taibai123'
print(name.isalnum()) #字符串由字母或数字组成
print(name.isalpha()) #字符串只由字母组成
print(name.isdecimal()) #字符串只由十进制组成

find       index      swapcase

 

2.4列表list

1，字符串只能存储少量的数据，对于大量的数据用字符串操作不方便也不易存储。

    2，字符串存储的数据类型太单一，只能是字符串类型。

 列表是python的基础数据类型之一 ,其他编程语言也有类似的数据类型.比如JS中的数 组, java中的数组等等. 它是以[ ]括起来, 每个元素用' , '隔开而且可以存放各种数据类型: 列表是python中的基础数据类型之一，其他语言中也有类似于列表的数据类。

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

2.4.1 列表的创建

# 创建一个列表有三种方式：

# 方式一：（常用）
l1 = [1, 2, '太白']

# 方式二：（不常用）
l1 = list()  # 空列表
# l1 = list(iterable)  # 可迭代对象
l1 = list('123')
print(l1)  # ['1', '2', '3']

# 方式三：列表推导式（后面的课程会讲到）
l1 = [i for i in range(1,5)]
print(l1)  # [1, 2, 3, 4]

2.4.2 列表的索引切片

 

l1 = ['a', 'b', '太白', 3, 666]
print(l1[0])  # 'a'
print(l1[-1])  # 666
print(l1[1:3])  # ['b', '太白']
print(l1[:-1])  # ['a', 'b', '太白', 3]
print(l1[::2])  # ['a', '太白', 666]
print(l1[::-1])  # [666, 3, '太白', 'b', 'a']

View Code

 

2.4.3. 增

# append 追加，给列表的最后面追加一个元素
l = [1, 2, 'a']
l.append(666)
print(l) # [1, 2, 'a', 666]

# insert  插入在列表的任意位置插入元素
l = [1, 2, 'a']
l.insert(1,'太白')
print(l) # [1, '太白', 2, 'a']

# extend  迭代着追加，在列表的最后面迭代着追加一组数据
l = [1, 2, 'a']
l.extend('太白a')
print(l)

View Code

# append 追加，给列表的最后面追加一个元素

# insert  插入在列表的任意位置插入元素

# extend  迭代着追加，在列表的最后面迭代着追加一组数据

2.4.4. 删

# pop  通过索引删除列表中对应的元素，该方法有返回值，返回值为删除的元素
l = ['太白', 'alex', 'WuSir', '女神']
ret = l.pop(1)
print(ret,l) # alex ['太白', 'WuSir', '女神']

# remove  通过元素删除列表中该元素
l = ['太白', 'alex', 'WuSir', '女神']
l.remove('alex')
print(l) # ['太白', 'WuSir', '女神']

# clear 清空列表
l = ['太白', 'alex', 'WuSir', '女神']
l.clear()
print(l) # []  

# del
#按照索引删除该元素
l = ['太白', 'alex', 'WuSir', '女神']
del l[2]
print(l) # ['太白', 'alex', '女神']

# 切片删除该元素
l = ['太白', 'alex', 'WuSir', '女神']
del l[1:]
print(l) # ['太白']

# 切片(步长)删除该元素
l = ['太白', 'alex', 'WuSir', '女神']
del l[::2]
print(l) # ['alex', '女神']

View Code

# pop  通过索引删除列表中对应的元素，该方法有返回值，返回值为删除的元素

# remove  通过元素删除列表中该元素

# clear 清空列表

# del
#按照索引删除该元素 （如：del l[2]）    # 切片删除该元素（如：del l[1:]）      # 切片(步长)删除该元素     （如：del l[::2]）

2.4.5. 改

# 按照索引改值
l = ['太白', 'alex', 'WuSir', '女神']
l[0] = '男神'
print(l) # ['男神', 'alex', 'WuSir', '女神']

# 按照切片改值(迭代着增加)
l = ['太白', 'alex', 'WuSir', '女神']
l[1:3] = 'abcdefg'
print(l) # ['太白', 'a', 'b', 'c', 'd', 'e', 'f', 'g', '女神'] 

# 按照切片(步长)改值(必须一一对应)
l = ['太白', 'alex', 'WuSir', '女神']
l[::2] = '对应'
print(l) # ['对', 'alex', '应', '女神']

View Code

# 按照索引改值

# 按照切片改值(迭代着增加)

# 按照切片(步长)改值(必须一一对应)

2.4.6. 查
切片去查，或者循环去查。

2.4.5 其他操作这些方法会在数据类型的补充时再给大家讲~

2.4.5、其他操作

count（数）（方法统计某个元素在列表中出现的次数）。

1 a = ["q","w","q","r","t","y"]
2 print(a.count("q"))

index（方法用于从列表中找出某个值第一个匹配项的索引位置）

1 a = ["q","w","r","t","y"]
2 print(a.index("r"))

sort （方法用于在原位置对列表进行排序）。

 reverse （方法将列表中的元素反向存放）。

1 a = [2,1,3,4,5]
2 a.sort()# 他没有返回值，所以只能打印a
3 print(a)
4 a.reverse()#他也没有返回值，所以只能打印a
5 print(a)

列表也可以相加与整数相乘

列表也可以相加(与int相乘)

 1 li = ["alex", "WuSir", "ritian", "barry", "wenzhou"]
 2 计算列表的长度并输出
 3 列表中追加元素"seven",并输出添加后的列表
 4 请在列表的第1个位置插入元素"Tony",并输出添加后的列表
 5 请修改列表第2个位置的元素为"Kelly",并输出修改后的列表
 6 请将列表l2=[1,"a",3,4,"heart"]的每一个元素添加到列表li中，一行代码实现，不允许循环添加。
 7 请将字符串s = "qwert"的每一个元素添加到列表li中，一行代码实现，不允许循环添加。
 8 请删除列表中的元素"ritian",并输出添加后的列表
 9 请删除列表中的第2个元素，并输出删除的元素和删除元素后的列表
10 请删除列表中的第2至4个元素，并输出删除元素后的列表

相应练习题

2.4.6 列表的嵌套

l1 = [1, 2, 'taibai', [1, 'WuSir', 3,]]
1, 将l1中的'taibai'变成大写并放回原处。
2，给小列表[1,'alex',3,]追加一个元素,'老男孩教育'。
3，将列表中的'alex'通过字符串拼接的方式在列表中变成'alexsb'

相应练习题

Where:(这个知识点用在什么地方)：

　　你需要存储大量的数据，且需要这些数据有序的时候。

　　制定一些特殊的数据群体：按顺序，按规则，自定制设计数据。

2.5元组tuple。

元组:俗称不可变的列表,又被成为只读列表,元祖也是python的基本数据类型之一,用小括号括起来,里面可以放任何数据类型的数据,查询可以,循环也可以,切片也可以.但就是不能改.

2.5.1 元组的索引切片

元组的索引切片

2.5.2 其他操作这些方法会在数据类型的补充时再给大家讲~

2.5.2 元组其他操作方法

因为元组的特性，直接从属于元组的元素不能更改，所以元组只能查看。

# 可以利用for循环查询

tu1 = ('a', 'b', '太白', 3, 666)
for i in tu1:
    print(i)

View Code

index：通过元素找索引（可切片），找到第一个元素就返回，找不到该元素即报错。

tu = ('太白', [1, 2, 3, ], 'WuSir', '女神')
print(tu.index('太白')) # 0

View Code

count: 获取某元素在列表中出现的次数

tu = ('太白', '太白', 'WuSir', '吴超')
print(tu.count('太白')) # 2

View Code

2.5.3 len

tu1 = (1,2,3,4,84,5,2,8,2,11,88,2)
print(len(tu1))

结果:
12　

View Code

Where:

    1，就是将一些非常重要的不可让人改动的数据放在元组中，只供查看。

    2，常用于元组的拆包（数据类型补充的时候会给大家讲到）。

 

 

 

标签：太白,alex,name,python,数据类型,元素,基础,列表,print
来源： https://www.cnblogs.com/lijin930121/p/11214750.html