目录
1.3 int 在python2 和 python3 中的区别
3.17 islower isupper upper lower
一、运算符
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
227
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
