Python 基本数据类型和序列类型

Posted 空白的Melody

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了Python 基本数据类型和序列类型相关的知识,希望对你有一定的参考价值。

python 3.6.4 中,有9种数据类型:

int, float, bool, complex, list, tuple, string, set, dict

(1).int 整型,不可变

(2).float 浮点型,不可变

(3).bool 布尔,True 和 False,不可变

(4).complex 科学计数,实部和虚部组成,如:2+2j,不可变。(不常用)

(5).list 列表,可变

(6).tuple 元组,不可变

(7).string 字符串,不可变

(8).set 集合,特点:无序且元素唯一,可变

(9).dict 字典,特点:键值对存在,键唯一,可变

序列类型:list, tuple, str 因为有序,所以可以索引。

散列类型:set, dict

(10).数据类型是用来表示信息的。

 

一、使用IDLE的情况下

打开IDLE,点击菜单栏中的"File" -> "New File",

在新文件中,保存起来。代码写完要运行,按F5。

其中要输出1+1,也需要放进print()中,不然按F5,看不到结果。

 

添加注释的三种方法:(注释的作用:解释说明,方便他人阅读)

1.单行注释:一个井号键 "#" 井号后的内容都会被解释器忽略。

2.多行注释:三个单引号 ‘‘‘abcde‘‘‘ 或 三个双引号 """abcde"""

3.直接用引号引起来,不赋值给变量,就是注释:‘abc‘ / "abc" / """abc"""

 

变量的命名规则:变量就是取名字。特点:同名的话,后者会覆盖前者。

1.由字母、下划线、数字组成。

2.不能以数字开头。

3.不能用关键字。

 

二、Python中的数值

Python中数值类型不可变(强类型语言),不可以:1 + "1"

Python中变量无类型(动态类型),无需在变量前写 int, string, float 等关键字。

 

三、Python完全面向对象

面向对象举例:叫了某个人去买瓶水,他把水买来就好了。

面向过程举例:叫了某个人去买瓶水,给他钱,跟他说买什么牌子,容量多少,下楼,出门左拐,过马路,到了小卖部,问老板买水,再回来。整个过程。

 

查看python3所有内置函数:dir(__builtins__) 注意是双下划线

 

查看python中所有的关键字:

技术分享图片
1 import keyword
2 print(keyword.kwlist)
View Code

四、基本数据类型(底层存放数据是二进制方式的)

(一).4种数值类型

技术分享图片
1 a = 1  # 整型
2 print(type(a))  # <class ‘int‘>
3 b = 1.1  # 浮点型
4 print(type(b))  # <class ‘float‘>
5 c = True  # 布尔值
6 print(type(c))  # <class ‘bool‘>
7 # 复数用于科学研究,日常并不常用
8 e = 1 + 1j  # 复数
9 print(type(e))  # <class ‘complex‘>
View Code

bool类型是有具体的数值,可参与算术运算。

True+1 -> 结果是:2

True+0 -> 结果是:1

True==2 -> 结果是:False

其中:== 与 is 的区别:is 用于判断两个变量引用对象是否为同一个, == 用于判断引用变量的值是否相等

另外注意一点:浮点型是不精确的。

先看如下代码的运行结果:

技术分享图片
1 a = 1
2 c = 1.1
3 print(c - a)  # 结果是:0.10000000000000009
View Code

需要精确运算,需要Decimal()方法:

技术分享图片
 1 import decimal  # 导入十进制的浮点型
 2 d = decimal.Decimal("1.1")  # 必须加引号,不然还是调用的float
 3 print(d - 1)  # 0.1
 4 
 5 # 源码中,括号内是object类型。
 6 """
 7 class Decimal(object):
 8     ‘‘‘Floating point class for decimal arithmetic.‘‘‘
 9 """
10 
11 """
12 python完全面向对象 要给参数指定一个数据类型 不然python就会默认。
13 1.1是个float浮点类型 不加引号的话 传过去了 对于object来说 1.1就是会被默认为float 然后继续执行float不精确运算
14 """
View Code

(二).两种除法:地板除、天花板除

(1).地板除:两个斜杠 //

print(5 // 2)  # 结果:2。只取整数部分,小数部分全部舍去

(2).天花板除:普通的除法,但要写在 math.ceil() 这个函数的括号内

import math
# 看见ceil() 抬头看天花板 向上取整
print(math.ceil(5 / 2))  # 结果:3。不管小数多少都会进位

(三).四舍五入的方法:round()

# 不用引入math模块
print(round(7 / 2))  # 结果:4。四舍五入

五、序列类型

简单来说,序列,序列,就是对象里面的元素是有顺序的。(下标索引从0开始)

(一).str:字符串是一个字符的序列(有顺序的,可索引取值),python设计时,固定了字符串不可变(想要改变得重新赋值)。

python3中,所有的字符都是Unicode字符(又称万国码、统一码)。

语法:用单引号/双引号/三引号包裹起来,赋值给一个变量的序列。

其中,一个中文汉字代表一个字符,不是字节!单个字符代表长度为1的字符串!

python是解释型语言,从上往下依次执行:

python有垃圾回收机制,引用计数,计数为0就回收了。

两个字符串之间的比较,是按ASCII码顺序比较的。

(1).索引(下标):字符在字符串中的偏移量。(位置是普通的理解,底层设计的是偏移量)

其中,-1代表倒数第一个,以此类推。

(2).str的几个方法:

? str.capitalize() 把字符串的首字母变成大写。

index() & find():find()没有的话,返回-1(返回0的话,代表下标为0,找到了,-1就不会冲突了)。index()没有的话会报错。

rindex() & rfind():同理于上,只是从右边开始找。

str.replace("old","new") 两个参数必须都是字符串,后面替换前面。

? str.isalpha() 检查是否只有字符构成。3.6.4中,汉字也可以识别。

? str.isnumerice() 检查字符串是否只有数字。(带小数就会返回False)

? str.isdigit() 只能用于判断是否为正整数。(3.6.4中,0被认定为是一个正整数,但是写成"-0"就不是了)

? str.isalnum() -> return bool,检查是否包含字母或数字。3.6.4中,满足其中一项就返回True。(带小数会返回False)

技术分享图片
a = "2018"
b = "aaa"
c = "2018aaa"
d = "12.34"
print(a.isalnum())  # True
print(b.isalnum())  # True
print(c.isalnum())  # True
print(d.isalnum())  # False
View Code

? str.isdecimal() -> return bool,检查字符串中是否只包含十进制数值。有小数会返回False(小数小于0,是十进制吗?当然返回False了)

? str.isidentifier() 检查字符串是否是有效标识符。实际测试后,总结:就是这个字符串要符合变量命名规则。

? str.split() 返回一个列表,默认以"空格"切割。其中括号中的默认参数 maxsplit,默认为-1,予以区分,如果是0的话就不切了。maxsplit=1 最大切一次。

s = "abc"
print(s.split(sep="b"))  # sep 定界符,默认空格
print(s)  # abc(s依旧没有被改变)

? str.partition(str) -> return tuple 从左往右,遇到指定的字符串就分割成:头、分割字符串、尾。

技术分享图片
s1 = "I am a good man"
print(s1.partition("good"))
# (‘I am a ‘, ‘good‘, ‘ man‘)
View Code

遇到第一个匹配的字符串就分割了:

s1 = "I am a good man"
print(s1.partition("a"))
# (‘I ‘, ‘a‘, ‘m a good man‘)

不同于str.split(),split()会把指定的那个元素给切掉了,这个指定的字符串不会出现在返回的list中。

但是str.partition()会把指定的字符串也给返回了。

? str.ljust(width_int,fillchar) 设置字符串宽度,并左对齐。width_int需要一个整型数值,设置字符串宽度;fillchar只能指定一个字符,指定以什么字符来填充,默认是"空格"

a = "aaa"
print(a.ljust(10, "*"))  # aaa*******

# 等价于:
print("{:*<10}".format(a))  # aaa*******

str.rjust() 同上同理使用,右对齐。

str.center() 同上同理使用,居中对齐。

? str.lower() 所有的字符都变成小写。只能用于汉语和英语的转换,遇到其他语种就无效了。

str.casefold() 用途更加广泛,可转换任何语言。可看此例:https://segmentfault.com/q/1010000004586740/a-1020000004586838

? str.upper() 所有的字符都变成大写。

? str.strip() strip这个单词是脱衣的意思,去掉字符串中左右两边的指定的字符。(有个长得类似的函数:str.lstrip()比较鸡肋,只是去除最左边的指定字符)

",ab,c,d,".strip(",")  # ab,c,d
#中间的不会被去掉
import string
a = " aaa bbb !"
print(a.strip(string.punctuation + string.whitespace))
# 运行结果:aaa bbb

此段代码中:

string.punctuation属性,是获取所有的标点符号 -> !"#$%&‘()*+,-./:;<=>[email protected][\]^_`{|}~

string.whitespace属性,不是普通意义上的空格,而是 -> x0bx0c

注意:在字符串中间出现的空格是不会被去掉的,要replace()一下。

? str.swapcase() 大写变小写,小写变大写。

? str.title() 所有的单词以大写开头,其余全部强转成小写。(英语是用空格来隔开单词的,一个空格一个单词)

a = "aa bB CC"
print(a.title())  # Aa Bb Cc

str.istitle() 是用来检查所有单词是否全部都"title化"了。有一个不符合就返回False

? str.zfill(width_int) 返回指定长度的字符串,右对齐,前面用"0"填充。(很鸡肋,固定用法,只能"0"来填充)

a = "abc"
print(a.zfill(5))  # 00abc

? str.translate(table) 根据给出的表,转换字符串中的字符

o_str = "aeiou"
t_str = "12345"

transtab = str.maketrans(o_str, t_str)  # 制作翻译表
print("abcde".translate(transtab))
# 运行结果:1bcd2

in 布尔操作符:检查前一个子串是否在后一个字串中,返回一个布尔值。比则正还快

name = "xinlan"
print("x" in name)  # True
print("X" in name)  # False 对大小写敏感

比较操作符:

# 比较操作符,按字符的顺序进行比较
name1 = "xinlan"
name2 = "xinlaN"
print(name1 > name2)  # True
# ASCII码中,大写在小写前面。"A" 65 , "a" 97

(3).字符串切片:记住左闭右开,包左不包右。

string[1:3] "tr"

string[1:] "tring"

string[:3] "str" 从头开始切3个元素

string[:-1] "strin" 从头切到最末位,但不包括-1位置的元素。

string[-3:] "ing" -3位置开始,切到末尾。

string[-3:-1] "in" 不包括-1位置的元素。

string[-1:-4] "" 什么都没有,因为步长默认是1,正方向的。前面开始、结尾都是反方向的,方向不一致,切不到任何东西。

 

(二).列表(list):li = [] 可变(可以在自身的基础上进行修改,不可描述的改变)。注:目前只试出了列表可以自加。

(1).列表常用的几个方法:

dir(list)查看属性和方法,会发现有"__iter__"就是可迭代的。

? list.append() 返回:None 不可言语的改变,需要调一下list的变量。

? list.count() 计数括号中那个元素在列表中出现了几次,不加参数会报错。

? list.extend(iterable) 将iterable中的元素顺序添加到列表的末尾。

# extend()方法 演示
li1 = ["a", "b"]
li2 = [1, 2]
li1.extend(li2)  # return None(不可描述的改变)
print(li1)  # [‘a‘, ‘b‘, 1, 2]

? list.index(value) 默认返回:括号中元素,第一次出现的索引位置。其中,该方法的可选参数:start,stop 遵循左闭右开的原则

# 找到第二个5的下标位置
li = [1, 2, 5, 7, 6, 5]
print(li.index(5, li.index(5) + 1))
"""
index(value,start_index)第二个参数是开始位置,
li.index(5) + 1 不加1的话找到是第一个5的下标位置。
这里先找到第一个5的位置,然后+1,就是往后找了。
"""

? list.insert(index,item) 指定索引位置,插入元素。

? list.pop(index) remove and return item at index (default last).

? list.remove(value) 删除第一次出现的值,如果value不存在就会报错。

? list.sort() -> return None.需要保证列表中元素的类型一样。默认ASCII排序。要看结果的话,直接调那个变量名。

# 按元素的长度排序
li = ["ab", "a", "bbb"]
li.sort(key=len)  # len在这里是方法体
print(li)  # [‘a‘, ‘ab‘, ‘bbb‘]
# 根据最大值排序
li = [(8, 9), (3, 4), (1, 10)]
li.sort(key=max)
print(li)  # [(3, 4), (8, 9), (1, 10)]
"""
(8, 9) 9最大
(3, 4) 4最大
(1, 10) 10最大
再根据这3个数进行排序
"""

sorted()是python的内置方法,列表本身不改变,而是先创建一个副本,需要重新赋值。sort()效率比sorted()快,但差别不大,一千万个int排序,只差0.793秒。

技术分享图片
 1 """
 2 亲自做了实验:
 3 当然代码这么写很不规范,这里只是做个实验。试完了,可以丢了。
 4 
 5 随机生成10,000,000(一千万)个int数值,分别用sort()和sorted()来排序。
 6 用时间戳来计算开始和结束过程中的秒数。
 7 
 8 时间戳小数太长了,自作主张给取到前4位(没四舍五入过,直接把后面删了)。
 9 
10 sort()耗时:16.3059
11 sorted()耗时:17.0989
12 
13 差别不大,0.793秒的差别
14 """
15 
16 import time
17 import random
18 
19 
20 def fun_count_time(li):
21     time_start = time.time()
22     sorted(li)
23     # li.sort()
24     time_end = time.time()
25 
26     print(time_end - time_start)
27 
28 
29 n = 1
30 max_rd = 10000000
31 li = []
32 while n < max_rd:
33     li.append(random.randint(1, max_rd))
34     n += 1
35 fun_count_time(li)
View Code

(2).列表切片:同样遵循左闭右开的原则,切片方向和步长方向要一致!

切片的操作符:[n:m] 左闭右开(包头不包尾)。

li[0:3] 左闭右开(包头不包尾),从下标0的元素可以取到,但是下标3的元素取不到。(正向索引从0开始,反向索引从-1开始)

步长:切片的时候,相邻元素之间的距离,每隔几个切一次。[star:stop:n] 第二个冒号后面是步长,从start切到end,每隔n个。(跨台阶的概念)

例如:li[0:5:-1] -> 取不出任何值,返回一个空列表。因为上面说过了:“切片方向和步长方向要一致”。这里步长错了,步长方向是反向了。

实用用法:li[::-1] 整个列表倒序了。

(三).元组:tuple -> tu = (1,2) 不可变。可强转成list,再操作。

# 创建空元组不可以在小括号内加逗号
tu = ()
print(type(tu))  # <class ‘tuple‘>

六、工厂方法(经过工厂加工一下)

a = "abc"
print(list(a))  # 结果:[‘a‘, ‘b‘, ‘c‘]
# 使用 工厂方法,将a的值反转输出
a = 789
print(int(str(a)[::-1]))
print(type(a))  # <class ‘int‘>
# 先强转成字符串,倒序。然后再强转成int
# 同理,字符串也可以转成list,然后再转换成string
print("".join(list("abcde"[::-1])))
"""
先会输出:[‘e‘, ‘d‘, ‘c‘, ‘b‘, ‘a‘]
.join()方法 把括号中的iterable对象,转换成字符串
"""

小练习:

# 有个时间形式是(20181206),通过整除和取余,来得到对应的日,月,年
time_date = 20181216
print("年:", time_date // 10000)  # 年: 2018
print("月:%.2d" % (time_date // 100 % 100))  # 月:12
print("日:%.2d" % (time_date % 100))  # 日:16
# 使用算术运算符,将a的值反转输出
a = 789
c = a // 100 + a // 10 % 10 * 10 + a % 10 * 100
print(c)
技术分享图片
# 演示 __iadd__()方法 往列表里面插值
li = [1, 2, 3]
li.__iadd__([614, 616])
"""
Implement self+=value
英文implement的意思是:使生效(使动结构)
这里就会对原列表进行改变,直接生成想要的add结果
同理shell中:li+=[614, 616] 的用法
"""
print("__iadd__()就是直接生效了:", li)
"""
而 __add__()方法 是直接返回了list
不会对原列表进行修改,所以需要赋值给一个新list变量
"""
View Code
# 判断字符串是否为回文
s = input("请输入一个字符串:")
g = lambda s: s.__eq__(s[::-1])  # equal的缩写:eq
print(g(s))

紧接上题,来一个“算法”解决方案:

技术分享图片
 1 # 算法方案
 2 def is_palindrome(s):
 3     n = 0
 4     start = 0
 5     end = len(s) - 1  # 不减就等着IndexError报错好了
 6     k = len(s)  # 比较几次就可以了
 7 
 8     """
 9     思路:通过取索引,首尾逐个相比。
10     例:"12321" 长度为5,奇数。首尾分别比较2次就可以了,只要这2次相同,中间那个字符不用理它了。
11     长度为偶数时,那就更好理解了。
12     """
13     while n < k / 2:  # 得到的是一个整数
14         if s[start] == s[end]:
15             start += 1
16             end -= 1
17             n += 1
18             continue
19         else:
20             return False  # return语句一旦执行,函数体就结束了。不用再break了
21             # break
22     else:  # 正常结束 说明是个回文 执行while体的else
23         return True
24 
25 
26 if __name__ == __main__:
27     while 1:
28         # 可以一直测试
29         s = input("请输入一个字符串:")
30         g = is_palindrome(s)
31         print(g)
View Code

 

以上是关于Python 基本数据类型和序列类型的主要内容,如果未能解决你的问题,请参考以下文章

Python基本内置数据类型都有哪些

:Python的基本数据类型-第二节:Python中表示“有序”(序列)的数据类型

Python中的基本数据类型之元组类型

Python 数据类型简介

python 数据类型

Python 标准库-json