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)
四、基本数据类型（底层存放数据是二进制方式的）
（一）.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'>
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
需要精确运算，需要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 """
（二）.两种除法：地板除、天花板除
（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
• 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 = "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)
(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))
紧接上题，来一个“算法”解决方案：
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)