No.002-Python-学习之路-Day2-num|String|Bytes|List|tuple|dict|集合的推导式

Data Type

number:

　　intger:

　　32位机器上为 -2**31 - 2**31

　　64位机器上为-2**63 - 2**63

　　在python 2 中年当字符串超了后，会自动变成long intger

　　在python 3 中没有相关的机制，无论intger多大均为int类型

　　16进制表示方法:0X53 或者 53BH

　　float:

　　表示方法:

　　　　　　方法一:普通表示法-0.002341

　　　　　　方法二:科学计数法-52.3E-4

　　Boolean

　　 True or False  0 or 1

　　

if True:
    print("Boolean value is True")
a = 0
if a:
    print("Boolean value is True")

String

　　1.字符串是可以拼接的

　　2.字符串是不支持修改的，比如a[1]值可以取出，但是a[1] = "A"是不行的，所以，字符串在修改的时候，事实上是直接做了替换；

name = "boy's name is Bruce"

#显示字符串中有多少个某字母
print(name.count("a"))
#将字符串的首字符大写()
print('alex li'.capitalize())
print('alex li'.title())# 把word首字符变为大写

#字符串居中，左对齐，右对齐，并不足50这个长度，用-
print(name.center(50, "-"))
print(name.ljust(50, '-'))
print(name.rjust(50, '-'))
print('lex li'.zfill(50)) #不够的用零填充

#string encode bytes
print(name.encode())
#判断string是不是以某结尾
print(name.endswith("ce"))

name = "boy's 	 name is Bruce"
#定义字符串中tab键的长度
print(name.expandtabs(tabsize=30))
#从下标1开始自左向右查找字符串，找到返回起始下标，未找到返回-1
print(name.find("name", 1)) # 用于切片，字符串也可以切片
print('alex li'.rfind('l')) # 找到最右边一个l，然后按照从左往右写编号

#经常用的format，用于将字符串中{}更换为相应的变量值
format_name = "Bruce"
format_age = 18
name = "name is {name},Age is {age}"
print(name.format(name=format_name, age=format_age))
#format_map仅可以用dict格式
print(name.format_map({'name': 'bruce', 'age': 12}))
#自左向右查某个字符的编号，区别于find()的是，如果没有某字符会报错
print(name.index('a'))

#is相关方法
print('abc23'.isalnum()) #包含英文字符及1-9 - 为true 如果包含特殊字符则为false
print('abc'.isalpha()) #纯英文字符
print('1.00'.isdecimal()) #十进制，比如16进制
print('12'.isdigit()) # 是否为整数
print('1A'.isidentifier()) # 判断是不是一个合法的标识符（是不是一个合法的变量名）
print('1a'.islower()) # 是否为小写
print('33.33'.isnumeric()) #是不是只有数字在里面，相似于isdigit
print(' '.isspace()) # 是不是一个空格
print('My Name Is'.istitle()) # 是不是每个首字符大写
print('Pring'.isprintable()) # 是不是可以打印的，主要是linux tty file dirve file
print('AAAA'.isupper()) # 是不是全大写

#将某个仅包含string的序列，通过+组合成一整个string
print('+'.join(["1", "2", "3"]))

#如果字符串中有字母，则全小写or大写输出
print("AAaa1".lower())
print("AAaa1".upper())
print('Alex Li'.swapcase()) # 大写变小写 小写变大写

#去空格及回车系列
print('
  AE!
'.lstrip())  # 去左边的回车及空格
print('
 AE! 
'.strip())   # 两边回车及空格都去
print('
 AE! 
'.rstrip())  # 去右边的回车及空格

# 建立字符串的对应关系，用来加密
p = str.maketrans("abcdef",'123456')
print("a1cde".translate(p))

# 替换
print('bruce'.replace('r','L',1))

# 按照分隔符分割字符串为列表，空即为空格
print('alex li1'.split(' '))
print('alex
+li'.splitlines()) #基本等同去split('/n')，优于split的是可以自动识别win及linux换行的不同

Bytes

　　字节类数据类型（二进制），区别于python2，在python3中年是独立的数据类型，主要用来存储音频或者视频之类。

　　bytes 与 string 可以互相转换,如在网络传输时，需要将string变为bytes类型并传输

　　

bytes.decode = string
string.encode = byte
"aa".encode('utf-8')

List

import copy

list = []
print("赋值为空的列表:{list1}".format(list1=list))

#存储:
list = ["aa", "bb", "cc", "dd"]

#取值:
print("最简单的遍历:{list}".format(list=list))
print("可用于浅copy的遍历:{list}".format(list=list[:]))
print("单个取值-左侧开始第一个:{list}".format(list=list[0]))
print("单个取值-左侧开始第一个:{list}".format(list=list[-1])) # 0 = -0 不多解释
print("切片取值-正向切片-顾头不顾尾:{list}".format(list=list[0:2])) #list[3]无法取出，记住顾头不顾尾
print("切片取值-反向切片-顾头不顾尾:{list}".format(list=list[-3:-1])) #list[-1]无法取出，记住顾头不顾尾
print("切片取值-切片-':'左侧为空代表从头:{list}".format(list=list[:3])) #从头开始
print("切片取值-切片-':'右侧为空代表从头:{list}".format(list=list[1:])) #到尾部结束
print("切片取值-切片-步幅为2:{list}".format(list=list[::2])) # 跳着取值

#修改:
list.append("ee")
print("增加-在列表最后追加元素:{list}".format(list=list))
list.insert(-1, "gg")
print("增加-在列表某元素前增加值:{list}".format(list=list))
list1 = ["ff", "11", "ff"]
list.extend(list1) # 扩展，将列表合并
print("增加-将两个列表合并:{list}".format(list=list))
list_del = list.pop(4) #取值并删除某元素，默认删最后一个元素
print("删除-删除{list_del}后列表为:{list}".format(list_del=list_del, list=list))
del list[4] #通用删除，在python中可以删除很多东西
print("删除-通用删除-列表为:{list}".format(list=list))
list.remove("ff") #从左往右删除第一个匹配的
print("删除-根据元素值删除-列表为:{list}".format(list=list))
list[2] = "CC"
print("修改-改值-列表为:{list}".format(list=list))
list.reverse()
print("修改-反转-列表为:{list}".format(list=list))
list.sort()
print("修改-排序-列表为:{list}".format(list=list)) #根据ASCII排序，从大到小（小写<大写<数字<特殊字符）

#查询:
print("查询-列表整体的元素数量:{list}".format(list=len(list)))
print("查询-列表中aa的数量:{list}".format(list=list.count("aa")))
print("查询-列表中aa的编号:{list}".format(list=list.index("aa")))

list.clear() #清空列表
del list #删除列表


# 浅copy只copy第一层值，如果有二层列表只是copy内存地址
# 第一层中，二层列表存储为内存指针
list = ["LiuXiaoMing", "ChenTie", ["Tianqi", "tianxia"], "ZhongyaZhou"]
# 区别于数字及字符串的赋值方式，如list2=list，并未生成任何独立的数据，仅仅是给予指针
# 即：变量的内存空间中存的是具体的值，而list，dict，tuple中存的是内存指针
# list2 = list[:]     # 浅copy方法一
# list2 = list(list)  # 浅copy方法二
list2 = list.copy() # 浅copy方法三
print("列表-修改-浅copy-list:{list1}".format(list1=list))
print("列表-修改-浅copy-list2:{list1}".format(list1=list2))
list[1] = "陈铁"
list[2][0] = "天气"
print("列表-修改-浅copy-list:{list1}".format(list1=list))
print("列表-修改-浅copy-list2:{list1}".format(list1=list2))

# 遍历的方法，用for遍历
for item in list:
    print("遍历方法一:", list.index(item), item)

for index, item in enumerate(list):
    print("遍历方法二:", index, item)

for item in enumerate(list):
    print("遍历方法三:", item)

# import copy中的copy的copy等价于list.copy
# copy.deepcopy为复制完全独立的两份数据
list = ["LiuXiaoMing", "ChenTie", ["Tianqi", "tianxia"], "ZhongyaZhou"]
list2 = copy.deepcopy(list)
print("列表-修改-深copy-list:{list1}".format(list1=list))
print("列表-修改-深copy-list2:{list1}".format(list1=list2))
list[1] = "陈铁"
list[2][0] = "天气"
print("列表-修改-深copy-list:{list1}".format(list1=list))
print("列表-修改-深copy-list2:{list1}".format(list1=list2))



list.clear()
print("列表-修改-清空:{list1}".format(list1=list))
del list1

# 浅copy的作用，浅层列表存储个体拥有的，深层的地方存储共性的地方

tuple

# tuple类似于列表，又称为只读列表
# tuple只可以读及切片，一但赋值，不可修改
tup = ("aa", 1, "bb")
tup_one_parameter = ("aa",)
print(tup.index("bb"))
print(tup.count("bb"))

dict

# dict 是一种key-vlaue的数据类型，通过key所在的索引来查数据，list中索引为位置,dict中索引为key
# dict 是无序的，这种无序指的是不能人为的排序，基本上是按照创建顺序来排序，但是这个也不是一个稳定的方法
# hash值相同时，是不可控制的
# 字典内容扩容，当字典默认空间不够时，会自动扩容，扩容后键序就会发生变化
info = {
    'stu1101': "TengLan Wu",
    'stu1102': "LongZe Luola",
    'stu1103': "XiaoZe Maliya",
    'stu1101': "Cang JingKong",
}

print(info)

# add 查询
print(info)
print(info["stu1102"]) # 除非100%确定，否则出错，建议使用get()方法
print(info.get('stu1104'))
print('stu1103' in info) #判断在dict中是否有这个数据
info["stu1102"] = "泷泽萝拉"
info["stu1104"] = "Cang Jingkong"
print(info.values())  # 仅取值
print(info.keys())  # 仅取key
print(info.items()) #Python 字典(Dictionary) items() 函数以列表返回可遍历的(键, 值) 元组数组。
print(list(info.values()))
print(list(info.keys()))
print(info)

info.setdefault("stu1105", "Boduo yejieyi") # setdefault() 取字典的值，如果取不到创建并赋值
info.setdefault("stu1101", "aaa") # setdefault() 取字典的值，如果取到，则不修改
print(info)

# del
del info["stu1101"]
info.pop("stu1102") #不同于list，必须写，否则出错
info.popitem() # 任意删除一个

info1 = {
    "stu1101":  "Cai Luoli",
    1: 2,
    2: 4
}

info.update(info1) #把两个dict合并，如果有交叉则替换，如果没有则创建
info2 = dict.fromkeys([6, 7, 8],[1, {"name":111}, 444]) # 初始化一个字典并赋予个值
print(info)
print(info2)
info2[7][1]["name"] = "all_change"
print(info2)

# 循环-1:直接取值，推荐使用该方式
for i in info:
    print(i, info[i])
# 循环-2:需要先转变成可遍历的元祖，然后再遍历，效率低下，数据量大时很耗时
for k, v in info.items():
    print(k, v)

 集合推导式

使用一句表达式构造一个[collection]式数据(list, tuple, dict, set)，可以包含过滤，转换等操作。

列表语法:[item for item in collection if codition]

# 列表推导式
list1 = [i for i in range(10000) if i % 2 == 0]
# 列表嵌套推导式
lists = [list(range(10)), list(range(10, 20))]
evens = [item for lst in lists for item in lst if item % 2 == 0]

字典语法:{key:value for item in collection if codition}

# 字典推导式
dict1 = {key: value for key, value in enumerate(reversed(list(range(10)))) if value % 2 == 0}
print(dict1)

集合语法:{item for item in collection if codition}

# 集合推导式
set1 = {item for item in range(10) if item % 3 == 0}
print(set1)