标签：
一、运算符
in#谁在......中
‘hello’ in “sdfjsdfjsdlkfjsd”
“li” in [‘li‘,‘ok‘]
二、基本的数据类型
int
a.创建方式
n1 = 123 #根据int类，创建了一个对象
n2 = int(123)#根据int类，创建了一个对象
b. int内部优化
1、n1 和 n2 内存地址相同
n1 = 123
n2 = n1
2、按理说n1和n2的内存地址不相同
即
n1= 123
n2 = 123
但是python内部做了优化， 在python中 -5~257以内的数，按照2 的方式写的时候，都是指向同一个内存
n1 = 123
n2 = 123
除此以外的数，都是n1和n2的内存地址不相同
n1 = 123123
n2 = 123123
3、id查看对象 的内存地址
n1= 123
i1 = id（n1）
print（i1）
c、int长度限制
32位系统 -**31~2**31-1
64位系统 -2**63~2**63-1 python2.2之后，超过int的最大长度后，会自动转换成long类型，long类型无长度限制
python3之后，int自己就长度限制
str.
a. 创建方式
s1 = "alex"
s1 = str(‘alex‘)
s1 = str(‘alex‘)
b. 特有功能
两端去除空格
s1.strip()
以 .. 开头
s1.startswith()
找子序列 "12","h"
s1.find()
将字符串中的某子序列替换成 指定的值
s1.replace()
变大写
s1.upper()
是。。。吗？
s1.isalpha()
c. 公共功能
索引：只能取一个元素
切片：取多个元素
len：
len("李露")
3.5 ==》 字符
for：
3.5 ==》 字符
编码、for：
name = "李露"
for i in name:
print(i)
bytes_list = bytes(i, encoding=‘utf-8‘)
print(bytes_list)
for b in bytes_list:
1、3.5 for循环时候，循环的每一个元素是 “字符”
2、字符 =》 字节
bytes_list = bytes("字符串",encoding=‘utf-8‘)
# utf-8 -> 3字节
# gbk -》 2字节
print(bytes_list) # 默认每一个字节都是16进制表示
for b in bytes_list:
print(b) # 默认每一个字节都是10进制表示
3、10进制的数字 ==》 2进制
len
id
bin(10进制的数字)
d、 bytes和str的转换
a = "李露"
# 将字符串转换成字节
b1 = bytes(a, encoding=‘utf-8‘)
print(b1)
b2 = bytes(a, encoding=‘gbk‘)
print(b2)
# 将字节转换成字符串
newa1 = str(b1, encoding="utf-8")
print(newa1)
newa2 = str(b2, encoding=‘gbk‘)
print(newa2)
###########
x = str()
创建字符串
转换成字符串，字节，编码
m = bytes()
创建字节
转换成字节，字符串，要编程什么编码类型的字节
list
可变元素的“集合”
-----------
str -> 创建字符串，或者将其他的转换成字符串
------------------------------------------
list -> 创建列表，将其他元素转换成列表
a. 创建和转换
1、创建
li = [11,22,33,4]
li = list()
li = list([11,22,33,4])
2、转换
s1 = "李露"
#for，字符 ==> 可迭代
l1 = list(s1) # fpr循环，将循环的每一个元素，当做列表的元素
["李", "露"]
print(l1)
s1 = "李露"
for，字符 ==> 可迭代
l1 = list(s1) # fpr循环，将循环的每一个元素，当做列表的元素
["李", "露"]
print(l1)
t2 = ("alex", "laonanhai", "seven")
l2 = list(t2)
print(l2)
# 字典
dic = {‘k1‘: "alex", "k2": ‘seven‘}
l3 = list(dic.items())
print(l3)
字符串，元组，字典 =》 列表
b. 列表特有功能
追加
li.append()
清除
li.clear()
扩展自己，用另外一个可迭代的对象，扩充到自己内部
str,list,dict,tuple
s = "李露"
li.extend(s)
print(li)
翻转，自己内部元素翻转
li.reverse()
向指定位置插入指定元素
li.insert(1, "X")
c. 公共功能
li = ["alex", "eric", ‘seven‘, 123]
索引：li[2]
切片：li[2:3]
for
len
d.
li = ["alex", "eric", ‘seven‘, 123]
li = [ "alex" , 123, {"k1":"v1", "k2": {"vv": (11,22,123), "ii": 456}}]
li[2] --> {"k1":"v1", "k2": {"vv": 123, "ii": 456}}
li[2][‘k2‘] ==> {"vv": 123, "ii": 456}
li[2][‘k2‘]["vv"] ==> (11,22,123)
li[2][‘k2‘]["vv"][2]
元组
a. 创建和转换
t = (11,22,33)
t = tuple((11,22,33))
t = tuple([]) # 字符串，列表，字典
b. 特有方法
count
index
c. 嵌套（元素不可修改）
t = (11,22,33)
t = (11,22,["alex", {"k1": "v1"}])
e. 元组的特性，不可修改，谁不可被修改
元组，儿子不能变
元组，儿子不能变，孙子，...
整理：
一般字符串，执行一个功能，生成一个新内容，原来内容不变
list,tuple,dict，执行一个功能，自身进行变化
字典：
1、创建
a = {"k1": 123}
a = dict()
li = [11,22,33]
new_dict = dict(enumerate(li))
print(new_dict)
2、字典内部功能
keys()
values()
items()
pop
标签：
原文地址：http://www.cnblogs.com/sunlieqiblog/p/5456636.html
