目录
一、运算符
1、算术运算符
2、比较运算符
3、赋值运算符
4、逻辑运算符
5、成员运算符
二、基本数据类型
1、数字
1.1 将字符串转为int
1.2 int 方法 bit_length
1.3 int 在python2 和 python3 中的区别
1.4 range 获取数字
2、布尔值
3、字符串
3.1 capitalize
3.2 casefold lower
3.3 center ljust rjust zfill
3.4 count
3.5 startswith endswith
3.6 find
3.7 index
3.8 expandtabs
3.9 format format_map
3.10 isalnum
3.11 isalpha
3.12 isdecimal isdigit
3.13 isprintable
3.14 isspace
3.15 istitle title
3.16 join
3.17 islower isupper upper lower
3.18 lstrip rstrip strip
3.19 maketrans translate
3.20 partition rpartition
3.21 split
3.22 splitlines
3.23 swapcase
3.24 isidentifier
3.25 replace
3.26 字符串常用方法
3.27 字符串的基本操作：循环、索引、切片、获取长度
4、列表
4.1 append
4.2 clear
4.3 copy
4.4 count
4.5 extend
4.6 index
4.7 insert
4.8 pop
4.9 remove
4.10 reverse
4.11 sort
4.12 列表的元素
4.13 索引：查询、修改、删除
4.14 切片：查询、修改、删除
4.15 列表的 for 循环
4.16 in 操作
4.17 字符串和列表的相互转换
4.18 字符串和列表替换的比较
5、元组
5.1 index
5.2 count
5.3索引操作
5.4 切片操作
5.5 for 循环
5.6 转换
6、字典
6.1 字典创建方式
6.2 clear
6.3 copy
6.4 fromkeys
6.5 get
6.6 items
6.7 keys
6.8 pop
6.9 popitem
6.10 setdefault
6.11 update
6.12 values
6.13 字典的key
6.14 索引操作
6.15 del 删除
6.16 for 循环
小结
一、运算符
1、算术运算符
2、比较运算符
3、赋值运算符
4、逻辑运算符
5、成员运算符
二、基本数据类型
1、数字
1.1 将字符串转为int
num_str = "123"
print(type(num_str), num_str) # <class 'str'> 123
num = int(num_str) # 将字符串转为int 类型
print(type(num), num) # <class 'int'> 123使用base进行解析
num4 = "1001"
print(int(num4, base=2)) # 基于base进行解析将字符串转为十进制数据，结果：9
num5 = "a1"
print(int(num5, base=16)) # 基于base进行解析将字符串转为十进制数据，结果：1611.2 int 方法 bit_length
二进制表示数据的最少长度
"""
Number of bits necessary to represent self in binary.
>>> bin(37)
'0b100101'
>>> (37).bit_length()
6
"""
num1 = 1
print(num1.bit_length()) # 1
num2 = 3
print(num2.bit_length()) # 2
num3 = 8
print(num3.bit_length()) # 41.3 int 在python2 和 python3 中的区别
在python3中数字只有int类型，在python2中数字存在 int 和 long类型
D:\08_python\02_workspace\v03_jichu\day009>python
Python 2.7.17 (v2.7.17:c2f86d86e6, Oct 19 2019, 21:01:17) [MSC v.1500 64 bit (AMD64)] on win32
>>> type(123456789)
<type 'int'>
>>> type(123456789123)
<type 'long'>
D:\08_python\02_workspace\v03_jichu>python3
Python 3.8.1 (tags/v3.8.1:1b293b6, Dec 18 2019, 23:11:46) [MSC v.1916 64 bit (AMD64)] on win32
>>> type(123456789)
<class 'int'>
>>> type(123456789123)
<class 'int'>1.4 range 获取数字
# 获取连续或是等步长的数字
# Python2中直接创建在内容中 ;python3中只有for循环时，才一个一个创建
print(list(range(10))) # [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
print(list(range(1, 10))) # [1, 2, 3, 4, 5, 6, 7, 8, 9]
print(list(range(1, 10, 2))) # [1, 3, 5, 7, 9]
2、布尔值
真 True 或 假 False
# 如果缺省，则返回 False
print(bool()) # False
# 传入数值，0 返回False, 否则返回True
print(bool(0)) # False
print(bool(1)) # True
print(bool(2)) # True
print(bool(-2)) # True
# 传入字符串， 空字符串返回False，否则返回True
print(bool("")) # False
print(bool("0")) # True
# 传入元组、字典、列表等，元素个数为空返回False, 否则返回True
print(bool(())) # 空元组 False
print(bool((1,))) # 非元组 True
print(bool([])) # 空列表 False
print(bool([1])) # 非空列表 True
print(bool({})) # 空字典 False
print(bool({"a":1})) # 非空字典 True布尔值为 False 的几种情况
# 布尔值为 False 的情况
print(bool(None)) # False
print(bool("")) # False
print(bool(())) # False
print(bool([])) # False
print(bool({})) # False
print(bool(0)) # False3、字符串
3.1 capitalize
首字母大写
print("abcde".capitalize()) # 把首字母大写 :Abcde3.2 casefold lower
所有字母变小，功能比lower更强大，很多未知的相应变小写
print("ABCDE".casefold()) # 所有字母变小写，功能比lower强大，很多未知的相应变小写 :abcde
print("ABCDE".lower()) # 所有字母变小写：abcde3.3 center ljust rjust zfill
设备宽度，并根据位置进行填充
print("abc".center(10, "*")) # 以字符串为中心，两边用填充字符补齐到设定长度 ：***abc****
test = "abc"
print(test.ljust(10, "*")) # 返回指定长度的左对齐字符串，使用指定填充符（默认是空格） ：abc*******
print(test.rjust(10, "*")) # ：*******abc
print(test.zfill(10)) # 根据给定长度，在左边填充0到指定长度 ：0000000abc3.4 count
在字符串中寻找子序列出现次数
print("abcABCabABa".count("ab")) # 计算子序列出现的次数: 2
print("abcABCabABa".count("ab", 3, 11)) # 从位置为3到位置11寻找子序列出现的次数 13.5 startswith endswith
判断以什么子序列开始或结尾
print("abcde".startswith("ab")) # 判断是否以ab 开始: True
print("abcde".endswith("de")) # 判断是否以de 结束： True3.6 find
从开始位置寻找，找到第一个子序列出现的位置
print("python".find("on")) # 寻找子序列所在的位置(找到返回起始位置，否则返回-1)：43.7 index
从开始位置寻找，找到第一个子序列出现的位置，找不到报错
print("python".index("py")) # 寻找子序列起始位置，找到返回起始位置序号，否则报错3.8 expandtabs
根据制表符扩展至指定长度
str = "username\temail\tpassword\nxu1\txu1@qq.com\t123\nxu1\txu1@qq.com\t123\nxu1\txu1@qq.com\t123"
expandtabs_str = str.expandtabs(20) # 返回制表符扩展到指定长度的副本，如果没有指定，默认是8
print(expandtabs_str)
#结果：
username email password
xu1 xu1@qq.com 123
xu1 xu1@qq.com 123
xu1 xu1@qq.com 1233.9 format format_map
替换由 大括号 （'{'和'}'）标识的占位符，并返回格式化版本
# 格式化，将一个字符串中的占位符替换为指定的值
print("i am {name}, age {num}".format(name="python", num=9)) # i am python, age 9
print("i am {0}, age {1}".format("python", 9)) # i am python, age 9
print("i am {name}, age {num}".format_map({"name": "python", "num": 9})) # i am python, age 93.10 isalnum
如果字符串是字母数字字符串，返回True，否则返回False; 字符串中所有字符都是字母数字且至少有一个字符
print("".isalnum()) # False
print("1212aaa".isalnum()) # True
print("1212-aa".isalnum()) # False3.11 isalpha
如果字符串至少有一个字符，并且都是字母(汉字)， 返回True , 否则返回 False
print("shi".isalpha()) # True
print("是".isalpha()) # True
print("12".isalpha()) # False3.12 isdecimal isdigit
isdecimal : 判断给定字符串所有字符是不是数字
isdigit : 判断给定字符串所有字符是否是从0-9的任何一个数字
#decimal 十进制的 小数的
#digit n. (从 0 到 9 的任何一个)数字
print("②".isdecimal()) # False
print("②".isdigit()) # True
print("2".isdecimal()) # True
print("2".isdigit()) # True
print("二".isdecimal()) # False
print("二".isdigit()) # False3.13 isprintable
如果字符串所有字符都可以打印，返回True，否则返回False
print("abc\tdef".isprintable()) # 有制表符，返回 False'3.14 isspace
如果字符串至少有一个字符并且都是空白格，返回True，否则返回False
print("".isspace()) # False
print("1 ".isspace()) # False
print(" ".isspace()) # True3.15 istitle title
istitle: 判断是否是标题格式，每个单词首字母大写
title: 将字符串转换为标题格式
test = "Python version 3"
print(test.istitle()) # False
test1 = test.title()
print(test1) # Python Version 3
print(test1.istitle()) # True3.16 join
对传入的可迭代对象，对象的元素是字符串的，将元素拼接并在中间插入指定字符串；返回拼接对象
print("_".join("abcd")) # a_b_c_d
print("_".join(("1", "2", "3",))) # 1_2_3
print("_".join(["1", "2", "3"])) # 1_2_33.17 islower isupper upper lower
# 判断字符串是否全部是大写 或 小写（至少包含一个字符的字符串）
print("aaa".islower()) # True
print("AAa".islower()) # False
print("AAA".isupper()) # True
print("AAa".isupper()) # False
# 将字符串转换为大写 或 小写
print("aaa".upper()) # AAA
print("AAA".lower()) # aaa3.18 lstrip rstrip strip
如果给定字符串，则移除字符串, 注意：会尽可能多的进行匹配
test = "1212312314"
print(test.lstrip("12")) # [312314]
print(test.lstrip("123")) # [4]
# 去除左右空白
test = " 1231234 "
print(test.lstrip()) # [1231234 ]
print(test.rstrip()) # [ 1231234]
print(test.strip()) # [1231234]
# 去除 \t \n
test = "123123\t"
print(test.strip()) # [123123]
test = "123123\n"
print(test.strip()) # [123123]3.19 maketrans translate
maketrans ： 生成一个转换表(dict对象)给str.translate() 使用，如果传入一个参数，应该是一个dict, 如果传入两个参数，两个参数的长度需要一样长
translate: 根据转换表替换给定字符串中匹配的字符到指定字符
test = "abcabcabcdefdefdef"
mt = str.maketrans("adf", "123") # 创建转换规则, 输出为 {97: 49, 100: 50, 102: 51}
print(test.translate(mt)) # 1bc1bc1bc2e32e32e33.20 partition rpartition
根据给定表示对字符串进行分割，返回一个长度魏三的元组：
元组的第一部分是分割标识前面的字符串
第二部分是分隔符自身
第三部分是发现的第一个分隔符后面的部分
print("aabccbddbeebdd".partition("b")) # ('aa', 'b', 'ccbddbeebdd')
print("aabccbddbeebdd".rpartition("b")) # 从右边进行分割： ('aabccbddbee', 'b', 'dd')3.21 split
根据分隔符进行分割，如果没事设置分割数量，则将字符串都进行分割，并用列表返回
print("aabccbddbeebbdd".split("b")) # ['aa', 'cc', 'dd', 'ee', '', 'dd']
print("aabccbddbeebbdd".split("b", 2)) # ['aa', 'cc', 'ddbeebbdd']3.22 splitlines
根据换行符进行分割，False： 不包含换行符，True： 包含换行符
print("aaa\nbbb\nccc".splitlines(False)) # ['aaa', 'bbb', 'ccc']
print("aaa\nbbb\nccc".splitlines(True)) # ['aaa\n', 'bbb\n', 'ccc']3.23 swapcase
将字符串中字符大小写转换
print("AbCd".swapcase()) # aBcD3.24 isidentifier
如果字符串是有效标识符，则 isidentifier() 方法返回 True，否则返回 False。
如果字符串仅包含字母数字字母（a-z）和（0-9）或下划线（_），则该字符串被视为有效标识符。有效的标识符不能以数字开头或包含任何空格
print("def1".isidentifier()) # True3.25 replace
根据替换字符串中的子序列，如果没有给定替换数量，将替换所有
print("abcabcdede".replace("abc", '123', 1)) # 123abcdede3.26 字符串常用方法
join # '_'.join("asdfasdf")
split
find
strip
upper
lower
replace
3.27 字符串的基本操作：循环、索引、切片、获取长度
# 1 for 循环
print("===============================================")
for c in "abc":
print(c)
# a
# b
# c
# 2 索引（下标）获取字符串中某一个字符
print("abc"[1]) # b
# print("abc"[4]) # IndexError: string index out of range
# 3 切片
print("abcd123"[1:2]) # b
print("abcd123"[1:-1]) # bcd12
print("abcd123"[1:-2]) # bcd1
print("abcd123"[1:]) # bcd123
# 4 获取长度
print(len("123")) # 3
4、列表
4.1 append
在列表末尾添加对象
li = [1, 2, 3]
print(li.append("a")) # None
print(li) # [1, 2, 3, 'a']4.2 clear
清空列表所有项目
print(li.clear()) # None
print(li) # []4.3 copy
浅拷贝 返回一个浅拷贝的列表
li = ["a", "b", "c"]
libak = li.copy() # ['a', 'b', 'c']
print(libak)4.4 count
返回指定元素出现的次数
li = ["a", "b", "c"]
print(li.count("a")) # 14.5 extend
迭代对象，扩展list
li = ["a", "b", "c"]
li.extend("123")
print(li) # ['a', 'b', 'c', '1', '2', '3']4.6 index
返回第一个查找元素的索引，如果查找元素不存在则报错
li = [11, 22, 33, 22, 44]
print(li.index(22)) # 1
# print(li.index(223)) # ValueError: 223 is not in list4.7 insert
将对象插入到索引前面
li = [11, 22, 33, 22, 44]
li.insert(1, "aa")
print(li) # [11, 'aa', 22, 33, 22, 44]4.8 pop
删除并返回指定索引的元素，如果没有指定索引，默认最后一个, 如果列表为空或是超出范围，将报 IndexError
li = [11, 22, 33, 22, 44]
print(li.pop()) # 44
print(li) # [11, 22, 33, 22]
li = [11, 22, 33, 22, 44]
print(li.pop(0)) # 11
print(li) # [22, 33, 22, 44]4.9 remove
删除第一个出现的元素，如果元素不存在，报 ValueError
# 删除的操作 pop remove clear del li[0] del li[2:4]
li = [11, 22, 33, 22, 44]
li.remove(22)
print(li) # [11, 33, 22, 44]
li = [11, 22, 33, 22, 44]
del li[0]
print(li) #4.10 reverse
将列表反转
li = [11, 22, 33, 22, 44]
li.reverse()
print(li) # [44, 22, 33, 22, 11]4.11 sort
按照升序排序并且返回None
li = [11, 44, 22, 33, 22]
li.sort(reverse=True)
print(li) # [44, 33, 22, 22, 11]4.12 列表的元素
列表的元素可以是数字、字符串、列表、布尔值、列表、字典等等,列表的值可以被修改（元组的一级元素不可以）
4.13 索引：查询、修改、删除
# 查询
li = [11, 22, 33, 22, 44]
print(li[1]) # 22
# 修改
li[1] = "aa"
print(li) # [11, 'aa', 33, 22, 44]
# 删除
li = [11, 22, 33, 22, 44]
del li[1]
print(li) # [11, 33, 22, 44]4.14 切片：查询、修改、删除
# 查询
li = [11, 22, 33, 22, 44]
print(li[1:3]) # [22, 33]
# 修改
li = [11, 22, 33, 22, 44]
li[1: 4] = ["aa"]
print(li) # [11, 'aa', 44]
# 删除
li = [11, 22, 33, 22, 44]
del li[2: 4]
print(li) # [11, 22, 44]4.15 列表的 for 循环
li = [11, 22, 33, 22, 44]
for l in li:
print(l)
# 结果：
# 11
# 22
# 33
# 22
# 444.16 in 操作
li = [11, 22, "aa", "bb", ["a1", "b1"]]
print(11 in li) # True4.17 字符串和列表的相互转换
#字符串转换为列表 传给list的对象必须可以迭代
s = "abcdef"
li = list(s)
print(li) # ['a', 'b', 'c', 'd', 'e', 'f']
# 列表转换为字符串
li = ['a', 'b', 'c', 'd', 'e', 'f']
print(str(li)) # ['a', 'b', 'c', 'd', 'e', 'f']
# 直接使用字符串join方法：列表中的元素只有字符串
print("".join(li)) # abcdef4.18 字符串和列表替换的比较
# 字符串的替换是返回一个新拷贝的对象（字符串创建后不可修改）
s = "abcd"
print(s.replace("a", "A"))
# 列表里面的元素可以被替换
li = [11,22,33,44]
li[0] = "aa"
print(li) # ['aa', 22, 33, 44]
5、元组
tuple 元组，一级元素不可被修改，不能被增加或者删除
5.1 index
返回第一个出现的索引，如果值不存在，抛出 ValueError
t = (11, 22, 33, 44)
print(type(t))
print(t.index(22, 0, -1)) # 15.2 count
返回查询元素出现的次数
t = (11, 22, 33, 44, 22)
print(t.count(22)) # 25.3索引操作
t = ("a", "b", "c", "d", "e")
print(t[2]) # c5.4 切片操作
t = ("a", "b", "c", "d", "e")
print(t[2: 4]) # ('c', 'd')5.5 for 循环
for item in t:
print(item)
# 结果：
# a
# b
# c
# d
# e5.6 转换
# 字符串和元组相互转换
s = "abcde"
print(tuple(s)) # ('a', 'b', 'c', 'd', 'e')
print("".join(('a', 'b', 'c', 'd', 'e'))) # abcde
# 列表和元组相互转换
print(tuple(["a", 1, True])) # ('a', 1, True)
print(list(("a", 1, True))) # ['a', 1, True]
6、字典
6.1 字典创建方式
字典是无需的，创建字典的方式
print({"a": 1, "b": 2}) # {'a': 1, 'b': 2}
print(dict(a=1, b=2)) # {'a': 1, 'b': 2}
print(dict({"a": 1, "b": 2})) # {'a': 1, 'b': 2}
print(dict.fromkeys(["a", "b"], 1)) # {'a': 1, 'b': 1}6.2 clear
清空所有的数据并返回None,
d = {"a": 1, "b": 2, "c": 3}
d.clear()
print(d) # {}6.3 copy
进行浅拷贝
d = {"a": 1, "b": 2, "c": 3}
dd = d.copy()
print(dd)
print("id(d) = ", id(d), ", id(dd) = ", id(dd)) # id(d) = 2191859711296 , id(dd) = 21918597113606.4 fromkeys
从一个可迭代对象创建字典，并设置默认值
print(dict.fromkeys(["a", "b"], 1)) # {'a': 1, 'b': 1}6.5 get
根据key 从字典中查询值，如果值不存在则返回默认值, 没有设置默认值则返回None
d = {"a": 1, "b": 2, "c": 3}
print(d.get("a", "0000")) # 1
print(d.get("d", "0000")) # 0000
print(d.get("d")) # None6.6 items
返回字典的 k-v 元组对象的列表
d = {"a": 1, "b": 2, "c": 3}
print(d.items()) # dict_items([('a', 1), ('b', 2), ('c', 3)])6.7 keys
返回字典的所有key的列表
d = {"a": 1, "b": 2, "c": 3}
print(d.keys()) # dict_keys(['a', 'b', 'c'])6.8 pop
删除指定key的数据，并返回其值，如果没有指定默认值并且key不存在，抛KeyError
d = {"a": 1, "b": 2, "c": 3}
print(d.pop("a", "000000")) # 1
print(d.pop("d", "000000")) # 000000
# print(d.pop("d")) # KeyError: 'd'6.9 popitem
删除并返回一个（key, value） 的二元组；成对按后进先出的顺序返回；如果dict为空，则引发KeyError。
d = {"a": 1, "b": 2, "c": 3}
print(d.popitem()) # ('c', 3)
print(d.popitem()) # ('b', 2)6.10 setdefault
设备一个值，如果key不存在，添加并设置默认值，如果key 存在，返回原来的值
d = {"a": 1, "b": 2, "c": 3}
print(d.setdefault("d", "0000")) # 0000
print(d) # {'a': 1, 'b': 2, 'c': 3, 'd': '0000'}
print(d.setdefault("a", "0000")) # 1
print(d) # {'a': 1, 'b': 2, 'c': 3, 'd': '0000'}6.11 update
更新字典， 传入一个字典或可迭代对象(有k-v)
d = {"a": 1, "b": 2, "c": 3}
d.update({"A": 1, "B": 2})
print(d) # {'a': 1, 'b': 2, 'c': 3, 'A': 1, 'B': 2}
d.update(k1=1, k2=2)
print(d) # {'a': 1, 'b': 2, 'c': 3, 'A': 1, 'B': 2, 'k1': 1, 'k2': 2}6.12 values
返回字典的值
d = {"a": 1, "b": 2, "c": 3}
print(d.values()) # dict_values([1, 2, 3])6.13 字典的key
可以是数字，布尔值，字符串；int(1) 和 True 看作是相同的key
print({"1": "1", True: "Ture"}) # {'1': '1', True: 'Ture'}
print({1: 1, "1": "1"}) # {1: 1, '1': '1'}
print({1: 1, "1": "1", True: "Ture"}) # {1: 'Ture', '1': '1'}6.14 索引操作
通过索引方式获取指定的元素, 如果key不存在，抛 KeyError
d = {"a": 1, "b": 2, "c": 3}
print(d["a"]) # 1
# print(d["d"]) # KeyError: 'd'
print(d.get("a")) # 16.15 del 删除
d = {"a": 1, "b": 2, "c": 3}
del d["a"]
print(d) # {'b': 2, 'c': 3}6.16 for 循环
d = {"a": 1, "b": 2, "c": 3}
for item in d:
print(item)
# 结果
# a
# b
# c
for item in d.keys():
print(item)
# 结果
# a
# b
# c
for item in d.values():
print(item)
# 结果
# 1
# 2
# 3
for item in d.items():
print(item)
# 结果
# ('a', 1)
# ('b', 2)
# ('c', 3)小结
一、数字
int(..)二、字符串
replace/find/join/strip/startswith/split/upper/lower/format
tempalte = "i am {name}, age : {age}"
v = tempalte.format(name='alex',age=19)
v = tempalte.format(**{"name": 'alex','age': 19})三、列表
append、extend、insert索引、切片、循环四、元组 索引、切片、循环、以及元素不能被修改
五、字典 get/update/keys/values/items for,索引
dic = {"k1": 'v1'}
v = "k1" in dic
print(v) # True
v = "v1" in dic.values()
print(v) # True
六、布尔值
0 1
bool(...)
None "" () [] {} 0 ==> False
