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中所有的关键字：

 import keyword
 print(keyword.kwlist)

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

（一）.4种数值类型

 a = 1  # 整型
 print(type(a))  # <class 'int'>
 b = 1.1  # 浮点型
 print(type(b))  # <class 'float'>
 c = True  # 布尔值
 print(type(c))  # <class 'bool'>
 # 复数用于科学研究，日常并不常用
 e = 1 + 1j  # 复数
 print(type(e))  # <class 'complex'>

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

True+1 -> 结果是：2

True+0 -> 结果是：1

True==2 -> 结果是：False

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

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

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

 a = 1
 c = 1.1
 print(c - a)  # 结果是：0.10000000000000009

需要精确运算，需要Decimal()方法：

 import decimal  # 导入十进制的浮点型
 d = decimal.Decimal("1.1")  # 必须加引号，不然还是调用的float
 print(d - 1)  # 0.1

 # 源码中，括号内是object类型。
 """
 class Decimal(object):
     '''Floating point class for decimal arithmetic.'''
 """

 """
 python完全面向对象 要给参数指定一个数据类型 不然python就会默认。
 1.1是个float浮点类型 不加引号的话 传过去了 对于object来说 1.1就是会被默认为float 然后继续执行float不精确运算
 """

（二）.两种除法：地板除、天花板除

（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 = ""
b = "aaa"
c = "2018aaa"
d = "12.34"
print(a.isalnum())  # True
print(b.isalnum())  # True
print(c.isalnum())  # True
print(d.isalnum())  # False

• 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')

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

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属性，是获取所有的标点符号 -> !"#$%&\'()*+,-./:;<=>?@[\\]^_`{|}~

string.whitespace属性，不是普通意义上的空格，而是 -> \t\n\r\x0b\x0c

注意：在字符串中间出现的空格是不会被去掉的，要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 = ""

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秒。

 """
 亲自做了实验：
 当然代码这么写很不规范，这里只是做个实验。试完了，可以丢了。

 随机生成10,000,000（一千万）个int数值，分别用sort()和sorted()来排序。
 用时间戳来计算开始和结束过程中的秒数。

 时间戳小数太长了，自作主张给取到前4位（没四舍五入过，直接把后面删了）。

 sort()耗时：16.3059
 sorted()耗时：17.0989

 差别不大，0.793秒的差别
 """

 import time
 import random

 def fun_count_time(li):
     time_start = time.time()
     sorted(li)
     # li.sort()
     time_end = time.time()

     print(time_end - time_start)

 n = 1
 max_rd = 10000000
 li = []
 while n < max_rd:
     li.append(random.randint(1, max_rd))
     n += 1
 fun_count_time(li)

(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变量
"""

# 判断字符串是否为回文
s = input("请输入一个字符串：")
g = lambda s: s.__eq__(s[::-1])  # equal的缩写：eq
print(g(s))

紧接上题，来一个“算法”解决方案：

 # 算法方案
 def is_palindrome(s):
     n = 0
     start = 0
     end = len(s) - 1  # 不减就等着IndexError报错好了
     k = len(s)  # 比较几次就可以了

     """
     思路：通过取索引，首尾逐个相比。
     例："12321" 长度为5，奇数。首尾分别比较2次就可以了，只要这2次相同，中间那个字符不用理它了。
     长度为偶数时，那就更好理解了。
     """
     while n < k / 2:  # 得到的是一个整数
         if s[start] == s[end]:
             start += 1
             end -= 1
             n += 1
             continue
         else:
             return False  # return语句一旦执行，函数体就结束了。不用再break了
             # break
     else:  # 正常结束 说明是个回文 执行while体的else
         return True

 if __name__ == '__main__':
     while 1:
         # 可以一直测试
         s = input("请输入一个字符串：")
         g = is_palindrome(s)
         print(g)