正文
python基础day2
小程序：扫一扫查出行【扫一扫了解最新限行尾号】
复制小程序
一、python字符串
字符串是 Python 中最常用的数据类型。可以使用引号('或")来创建字符串
1.1Python访问字符串中的值
Python不支持单字符类型，单字符在 Python 中也是作为一个字符串使用。
Python访问子字符串，可以使用方括号来截取字符串，如下实例
var1 = 'Hello World!'
var2 = "Python Runoob"
print ("var1[0]: ", var1[0])
print ("var2[1:5]: ", var2[1:5])
结果：
var1[0]: H
var2[1:5]: ytho
1.2Python字符串更新
var1 = 'Hello World!'
print (var1[0:6]+"123")
结果：
Hello 123
1.3Python转义字符
var1 = 'Hello World!'
print (var1[0:6]+"123")
结果：
Hello 123
在需要在字符中使用特殊字符时，python用反斜杠(\)转义字符。如下表：
|
转义字符 |
描述 |
|
\(在行尾时) |
续行符 |
|
\\ |
反斜杠符号 |
|
\' |
单引号 |
|
\" |
双引号 |
|
\a |
响铃 |
|
\b |
退格(Backspace) |
|
\e |
转义 |
|
\000 |
空 |
|
\n |
换行 |
|
\v |
纵向制表符 |
|
\t |
横向制表符 |
|
\r |
回车 |
|
\f |
换页 |
|
\oyy |
八进制数，yy代表的字符，例如：\o12代表换行 |
|
\xyy |
十六进制数，yy代表的字符，例如：\x0a代表换行 |
|
\other |
其它的字符以普通格式输出 |
1.4Python字符串运算符
下表实例变量 a 值为字符串 "Hello"，b 变量值为 "Python"：
|
操作符 |
描述 |
实例 |
|
+ |
字符串连接 |
>>>a + b 'HelloPython' |
|
* |
重复输出字符串 |
>>>a * 2 'HelloHello' |
|
[] |
通过索引获取字符串中字符 |
>>>a[1] 'e' |
|
[ : ] |
截取字符串中的一部分 |
>>>a[1:4] 'ell' |
|
in |
成员运算符 - 如果字符串中包含给定的字符返回 True |
>>>"H" in a True |
|
not in |
成员运算符 - 如果字符串中不包含给定的字符返回 True |
>>>"M" not in a True |
|
r/R |
原始字符串 - 原始字符串：所有的字符串都是直接按照字面的意思来使用，没有转义特殊或不能打印的字符。 原始字符串除在字符串的第一个引号前加上字母"r"（可以大小写）以外，与普通字符串有着几乎完全相同的语法。 |
>>>print r'\n' \n >>> print R'\n' \n |
1.5Python字符串格式化
Python 支持格式化字符串的输出 。尽管这样可能会用到非常复杂的表达式，但最基本的用法是将一个值插入到一个有字符串格式符 %s 的字符串中。
在 Python 中，字符串格式化使用与 C 中 sprintf 函数一样的语法。
>>> print ("我叫 %s 今年 %d 岁!" % ('小明', 10))
我叫 小明 今年 10 岁!
|
方法 |
描述 |
|
string.capitalize() |
把字符串的第一个字符大写 |
|
string.center(width) |
返回一个原字符串居中,并使用空格填充至长度 width 的新字符串 |
|
string.count(str, beg=0, end=len(string)) |
返回 str 在 string 里面出现的次数，如果 beg 或者 end 指定则返回指定范围内 str 出现的次数 |
|
string.decode(encoding='UTF-8', errors='strict') |
以 encoding 指定的编码格式解码 string，如果出错默认报一个 ValueError 的 异 常 ， 除 非 errors 指 定 的 是 'ignore' 或 者'replace' |
|
string.encode(encoding='UTF-8', errors='strict') |
以 encoding 指定的编码格式编码 string，如果出错默认报一个ValueError 的异常，除非 errors 指定的是'ignore'或者'replace' |
|
string.endswith(obj, beg=0, end=len(string)) |
检查字符串是否以 obj 结束，如果beg 或者 end 指定则检查指定的范围内是否以 obj 结束，如果是，返回 True,否则返回 False. |
|
string.expandtabs(tabsize=8) |
把字符串 string 中的 tab 符号转为空格，tab 符号默认的空格数是 8。 |
|
string.find(str, beg=0, end=len(string)) |
检测 str 是否包含在 string 中，如果 beg 和 end 指定范围，则检查是否包含在指定范围内，如果是返回开始的索引值，否则返回-1 |
|
string.index(str, beg=0, end=len(string)) |
跟find()方法一样，只不过如果str不在 string中会报一个异常. |
|
string.isalnum() |
如果 string 至少有一个字符并且所有字符都是字母或数字则返 回 True,否则返回 False |
|
string.isalpha() |
如果 string 至少有一个字符并且所有字符都是字母则返回 True, 否则返回 False |
|
string.isdecimal() |
如果 string 只包含十进制数字则返回 True 否则返回 False. |
|
string.isdigit() |
如果 string 只包含数字则返回 True 否则返回 False. |
|
string.islower() |
如果 string 中包含至少一个区分大小写的字符，并且所有这些(区分大小写的)字符都是小写，则返回 True，否则返回 False |
|
string.isnumeric() |
如果 string 中只包含数字字符，则返回 True，否则返回 False |
|
string.isspace() |
如果 string 中只包含空格，则返回 True，否则返回 False. |
|
string.istitle() |
如果 string 是标题化的(见 title())则返回 True，否则返回 False |
|
string.isupper() |
如果 string 中包含至少一个区分大小写的字符，并且所有这些(区分大小写的)字符都是大写，则返回 True，否则返回 False |
|
string.join(seq) |
以 string 作为分隔符，将 seq 中所有的元素(的字符串表示)合并为一个新的字符串 |
|
string.ljust(width) |
返回一个原字符串左对齐,并使用空格填充至长度 width 的新字符串 |
|
string.lower() |
转换 string 中所有大写字符为小写. |
|
string.lstrip() |
截掉 string 左边的空格 |
|
string.maketrans(intab, outtab]) |
maketrans() 方法用于创建字符映射的转换表，对于接受两个参数的最简单的调用方式，第一个参数是字符串，表示需要转换的字符，第二个参数也是字符串表示转换的目标。 |
|
max(str) |
返回字符串 str 中最大的字母。 |
|
min(str) |
返回字符串 str 中最小的字母。 |
|
string.partition(str) |
有点像 find()和 split()的结合体,从 str 出现的第一个位置起,把 字 符 串 string 分 成 一 个 3 元 素 的 元 组 (string_pre_str,str,string_post_str),如果 string 中不包含str 则 string_pre_str == string. |
|
string.replace(str1, str2, num=string.count(str1)) |
把 string 中的 str1 替换成 str2,如果 num 指定，则替换不超过 num 次. |
|
string.rfind(str, beg=0,end=len(string) ) |
类似于 find()函数，不过是从右边开始查找. |
|
string.rindex( str, beg=0,end=len(string)) |
类似于 index()，不过是从右边开始. |
|
string.rjust(width) |
返回一个原字符串右对齐,并使用空格填充至长度 width 的新字符串 |
|
string.rpartition(str) |
类似于 partition()函数,不过是从右边开始查找. |
|
string.rstrip() |
删除 string 字符串末尾的空格. |
|
string.split(str="", num=string.count(str)) |
以 str 为分隔符切片 string，如果 num有指定值，则仅分隔 num 个子字符串 |
|
string.splitlines(num=string.count('\n')) |
按照行分隔，返回一个包含各行作为元素的列表，如果 num 指定则仅切片 num 个行. |
|
string.startswith(obj, beg=0,end=len(string)) |
检查字符串是否是以 obj 开头，是则返回 True，否则返回 False。如果beg 和 end 指定值，则在指定范围内检查. |
|
string.strip([obj]) |
在 string 上执行 lstrip()和 rstrip() |
|
string.swapcase() |
翻转 string 中的大小写 |
|
string.title() |
返回"标题化"的 string,就是说所有单词都是以大写开始，其余字母均为小写(见 istitle()) |
|
string.translate(str, del="") |
根据 str 给出的表(包含 256 个字符)转换 string 的字符, 要过滤掉的字符放到 del 参数中 |
|
string.upper() |
转换 string 中的小写字母为大写 |
|
string.zfill(width) |
返回长度为 width 的字符串，原字符串 string 右对齐，前面填充0 |
|
string.isdecimal() |
isdecimal()方法检查字符串是否只包含十进制字符。这种方法只存在于unicode对象。 |
二．list列表
列表是Python中最基本的数据结构。序列中的每个元素都分配一个数字 - 它的位置，或索引，第一个索引是0，第二个索引是1，依此类推。
Python有6个序列的内置类型，但最常见的是列表和元组。
列表都可以进行的操作包括索引，切片，加，乘，检查成员。
此外，Python已经内置确定序列的长度以及确定最大和最小的元素的方法。
列表是最常用的Python数据类型，它可以作为一个方括号内的逗号分隔值出现。
列表的数据项不需要具有相同的类型
创建一个列表，只要把逗号分隔的不同的数据项使用方括号括起来即可。如下所示
>>> li = [1,2,3,4,5]
>>> print (li)
[1, 2, 3, 4, 5]
与字符串的索引一样，列表索引从0开始。列表可以进行截取、组合等
2.1访问列表中的值
l1 = ["a","b","c","d"]
print (l1[1])
结果：b
反向输出
print(l1[::-1])
结果：
['d', 'c', 'b', 'a']
分片取值
print(l1[1:3])
结果：['b', 'c'] 顾头不顾尾，取结尾需要在结尾加1
2.2更新列表
l1 = ["a","b","c","d"]
print (l1[1])
结果：b
反向输出
print(l1[::-1])
结果：
['d', 'c', 'b', 'a']
分片取值
print(l1[1:3])
结果：['b', 'c'] 顾头不顾尾，取结尾需要在结尾加1
直接赋值到列表中
list = ['Google', 'Runoob', 1997, 2000]
print("第三个元素为 : ", list[2])
list[2] = 2001
print("更新后的第三个元素为 : ", list[2])
第三个元素为 : 1997
更新后的第三个元素为 : 2001
2.3删除列表元素
2.3.1.remove:
删除单个元素，删除首个符合条件的元素，按值删除
举例说明:
>>> str=[1,2,3,4,5,2,6]
>>> str.remove(2)
>>> str
[1, 3, 4, 5, 2, 6]
clear清空列表
str=[1,2,3,4,5,2,6]
str.clear()
print(str)
2.3.2.pop:
删除单个或多个元素，按位删除(根据索引删除)
>>> str=[0,1,2,3,4,5,6]
>>> str.pop(1) #pop删除时会返回被删除的元素
1
>>> str
[0, 2, 3, 4, 5, 6]
>>> str2=['abc','bcd','dce']
>>> str2.pop(2)
'dce'
>>> str2
['abc', 'bcd']
2.3.3.del：
它是根据索引(元素所在位置)来删除
举例说明:
>>> str=[1,2,3,4,5,2,6]
>>> del str[1]
>>> str
[1, 3, 4, 5, 2, 6]
>>> str2=['abc','bcd','dce']
>>> del str2[1]
>>> str2
['abc', 'dce']
>>> str=[1,2,3,4,5,2,6]
>>> str.remove(2)
>>> str
[1, 3, 4, 5, 2, 6]
clear清空列表
str=[1,2,3,4,5,2,6]
str.clear()
print(str)
>>> str=[0,1,2,3,4,5,6]
>>> str.pop(1) #pop删除时会返回被删除的元素
1
>>> str
[0, 2, 3, 4, 5, 6]
>>> str2=['abc','bcd','dce']
>>> str2.pop(2)
'dce'
>>> str2
['abc', 'bcd']
>>> str=[1,2,3,4,5,2,6]
>>> del str[1]
>>> str
[1, 3, 4, 5, 2, 6]
>>> str2=['abc','bcd','dce']
>>> del str2[1]
>>> str2
['abc', 'dce']
除此之外，del还可以删除指定范围内的值。
>>> str=[0,1,2,3,4,5,6]
>>> del str[2:4] #删除从第2个元素开始，到第4个为止的元素(但是不包括尾部元素)
>>> str
[0, 1, 4, 5, 6]
del 也可以删除整个数据对象(列表、集合等)
>>> str=[0,1,2,3,4,5,6]
>>> del str
>>> str #删除后，找不到对象
Traceback (most recent call last):
File "<pyshell#27>", line 1, in <module>
str
NameError: name 'str' is not defined
注意：del是删除引用(变量)而不是删除对象(数据)，对象由自动垃圾回收机制（GC）删除。
补充: 删除元素的变相方法
s1=(1,2,3,4,5,6)
s2=(2,3,5)
s3=[]
for i in s1:
if i not in s2:
s3.append(i)
print 's1-1:',s1
s1=s3
print 's2:',s2
print 's3:',s3
print 's1-2:',s1
2.4追加
2.4.1 append
利用append()直接在list末尾追加元素：
l1 = ['Google', 'Runoob', 1997, 2000]
l1.append(100)
print(l1)
结果：
['Google', 'Runoob', 1997, 2000, 100]
2.4.2 insert
利用insert( , )在某个位置添加元素：（需要传两个参数，第一个是索引的位置，第二个是元素值）
l1 = ['Google', 'Runoob', 1997, 2000]
l1.insert(0,888)
print(l1)
结果：
[888, 'Google', 'Runoob', 1997, 2000]
三．字典
字典是另一种可变容器模型，且可存储任意类型对象。
字典的每个键值 key=>value 对用冒号 : 分割，每个键值对之间用逗号 , 分割，整个字典包括在花括号 {} 中
字典的key是唯一的。key 必须是不可变的数据类型。
key:不可变的数据类型(可哈希)：str，bool，tuple，int。
value：任意数据类型。
数据类型分类：
不可变的数据类型(可哈希)：str，bool，tuple，int
可变的数据类型：dict，list，set。
容器类数据类型：list，tuple，dict，set.
字典：存储数据多，关系型数据，查询速度快（二分查找）。
3.6版本之前，字典是无序的，3.6之后字典是有序的。
3.1增
dict1 = {'name':'pjh', 'age':'18' }
dict1['sex']='man'
print(dict1)
结果：
{'name': 'pjh', 'age': '18', 'sex': 'man'}
dict1 = {'name':'pjh', 'age':'18' }
dict1.setdefault('sex','man')
print(dict1)
结果：
{'name': 'pjh', 'age': '18', 'sex': 'man'}
3.2删
3.2.1pop删除
dict1 = {'name':'pjh', 'age':'18' }
dict1.pop('age')
print(dict1)
结果：
{'name': 'pjh'}
3.2.2del删除
dict1 = {'name':'pjh', 'age':'18' }
del dict1["age"]
print(dict1)
结果
{'name': 'pjh'}
3.3.3clear清空字典
dict1 = {'name':'pjh', 'age':'18' }
dict1.clear()
print(dict1)
结果
{}
3.3改
dict1 = {'name':'pjh', 'age':'18' }
dict1["name"]="shuaige"
print(dict1)
结果：
{'name': 'shuaige', 'age': '18'}
3.4查
dict1 = {'name':'pjh', 'age':'18' }
print(dict1['name']) //直接返回值 ，但是不存在会报错
print(dict1.get('name2')) //不存在显示为空
结果：
pjh
None
4.元组
dict1 = {'name':'pjh', 'age':'18' }
dict1['sex']='man'
print(dict1)
结果：
{'name': 'pjh', 'age': '18', 'sex': 'man'}
dict1 = {'name':'pjh', 'age':'18' }
dict1.setdefault('sex','man')
print(dict1)
结果：
{'name': 'pjh', 'age': '18', 'sex': 'man'}
3.2.1pop删除
dict1 = {'name':'pjh', 'age':'18' }
dict1.pop('age')
print(dict1)
结果：
{'name': 'pjh'}
3.2.2del删除
dict1 = {'name':'pjh', 'age':'18' }
del dict1["age"]
print(dict1)
结果
{'name': 'pjh'}
3.3.3clear清空字典
dict1 = {'name':'pjh', 'age':'18' }
dict1.clear()
print(dict1)
结果
{}
3.3改
dict1 = {'name':'pjh', 'age':'18' }
dict1["name"]="shuaige"
print(dict1)
结果：
{'name': 'shuaige', 'age': '18'}
3.4查
dict1 = {'name':'pjh', 'age':'18' }
print(dict1['name']) //直接返回值 ，但是不存在会报错
print(dict1.get('name2')) //不存在显示为空
结果：
pjh
None
4.元组
dict1 = {'name':'pjh', 'age':'18' }
dict1["name"]="shuaige"
print(dict1)
结果：
{'name': 'shuaige', 'age': '18'}
dict1 = {'name':'pjh', 'age':'18' }
print(dict1['name']) //直接返回值 ，但是不存在会报错
print(dict1.get('name2')) //不存在显示为空
结果：
pjh
None
4.元组
因为元组不经常使用，这里不做详细介绍
tu = (11,2,True,[2,3,4],'alex')
for i in tu:
print(i)
print(tu[1])
print(tu[:3:2])
print(tu.index(True))
print(tu.count(2))
print(len(tu))
tu[-2].append(666)
print(tu)
结果：
11
2
True
[2, 3, 4]
alex
2
(11, True)
2
1
5
(11, 2, True, [2, 3, 4, 666], 'alex')
五、集合：
无序，不重复的数据类型。它里面的元素必须是可哈希的。但是集合本身是不可哈希的。
1：关系测试。交集并集，子集，差集....
2,去重。（列表的去重）
l1 = [1,1,2,2,3,3,4,5,6,6]
l2 = list(set(l1)) //先把l1转换成集合，然后集合转换成列表
print(l2)
结果：
[1, 2, 3, 4, 5, 6] //去除了重复的部分
5.1增
set1 = {1,'pjh',False,(1,2,3)}
set1.add(666)
print (set1)
结果：
{False, 1, (1, 2, 3), 666, 'pjh'}
5.2删
set1 = {1,'pjh',False,(1,2,3)}
set1.remove(1)
print (set1)
结果：
{False, 'pjh', (1, 2, 3)}
set1 = {1,'pjh',False,(1,2,3)}
set1.pop() //随机删除一个数
print (set1)
set1 = {1,'pjh',False,(1,2,3)}
set1.clear() //清理集合
print (set1)
set1 = {1,'pjh',False,(1,2,3)}
del set1 //从内存中删除集合
print (set1)
5.3交集
set1 = {1,2,3,4,5}
set2 = {4,5,6,7,8}
print(set1 & set2)
print(set1.intersection(set2))
结果：
{4, 5}
{4, 5}
5.4并集
set1 = {1,2,3,4,5}
set2 = {4,5,6,7,8}
print(set1 | set2)
print(set1.union(set2))
结果：
{1, 2, 3, 4, 5, 6, 7, 8}
{1, 2, 3, 4, 5, 6, 7, 8}
set1 = {1,'pjh',False,(1,2,3)}
set1.add(666)
print (set1)
结果：
{False, 1, (1, 2, 3), 666, 'pjh'}
set1 = {1,'pjh',False,(1,2,3)}
set1.remove(1)
print (set1)
结果：
{False, 'pjh', (1, 2, 3)}
set1 = {1,'pjh',False,(1,2,3)}
set1.pop() //随机删除一个数
print (set1)
set1 = {1,'pjh',False,(1,2,3)}
set1.clear() //清理集合
print (set1)
set1 = {1,'pjh',False,(1,2,3)}
del set1 //从内存中删除集合
print (set1)
5.3交集
set1 = {1,2,3,4,5}
set2 = {4,5,6,7,8}
print(set1 & set2)
print(set1.intersection(set2))
结果：
{4, 5}
{4, 5}
5.4并集
set1 = {1,2,3,4,5}
set2 = {4,5,6,7,8}
print(set1 | set2)
print(set1.union(set2))
结果：
{1, 2, 3, 4, 5, 6, 7, 8}
{1, 2, 3, 4, 5, 6, 7, 8}
set1 = {1,2,3,4,5}
set2 = {4,5,6,7,8}
print(set1 & set2)
print(set1.intersection(set2))
结果：
{4, 5}
{4, 5}
set1 = {1,2,3,4,5}
set2 = {4,5,6,7,8}
print(set1 | set2)
print(set1.union(set2))
结果：
{1, 2, 3, 4, 5, 6, 7, 8}
{1, 2, 3, 4, 5, 6, 7, 8}
5.5差集
set1 = {1,2,3,4,5}
set2 = {4,5,6,7,8}
print(set1 - set2)
print(set1.difference(set2))
结果
{1, 2, 3}
{1, 2, 3}
5.6 反差集
取两个集合中不相同的部分
set1 = {1,2,3,4,5}
set2 = {4,5,6,7,8}
print(set1 ^ set2)
print(set1.symmetric_difference(set2))
结果
{1, 2, 3, 6, 7, 8}
{1, 2, 3, 6, 7, 8}
5.5子集
set1 = {1,2,3}
set2 = {1,2,3,4,5,6,7,8}
print(set1 < set2)
print(set1.issubset(set2))
结果
True
True
六．数据类型补充
6.1循环删除列表
set1 = {1,2,3}
set2 = {1,2,3,4,5,6,7,8}
print(set1 < set2)
print(set1.issubset(set2))
结果
True
True
6.1循环删除列表
再循环一个列表时，不要对列表进行删除的动作(改变列表元素的个数动作)，会出错
l1 = ['alex', 'wusir', 'taibai', 'barry', '老男孩']
# 删除奇数索引的内容
del l1[1::2]
print(l1)
结果：
['alex', 'taibai', '老男孩']
或者
for i in range(len(l1)):
print(l1)
print(i)
if i % 2 == 1:
del l1[i]
6.2range
range 可定制的数字列表
for i in range(10): //输出0-9
print(i)
for i in range(1,10): //输出1-9
print(i)
for i in range(1,10,2): //输出1-9.步长为2
print(i)
for i in range(10,1,-1): //输出10-2，倒叙
print(i)
6.3循环删除字典
dict 再循环字典时，不要改变字典的大小。
#删除带有k的键值对，以索引删除会出现错误
dic = {'k1':'v1','k2':'v2','k3':'v3','r':666}
l1 = []
for i in dic:
if 'k' in i:
l1.append(i)
for i in l1:
del dic[i]
print(dic)
结果：
{'r': 666}
6.4
tu 如果元组里面只有一个元素并且没有逗号隔开，那么他的数据类型与该元素一致
注意如下的数据类型
tu1 = (1)
print(tu1,type(tu1))
tu2 = ('alex')
print(tu2,type(tu2)) tu3 = (['alex',1,2])
print(tu3,type(tu3))
结果
1 <class 'int'>
alex <class 'str'>
['alex', 1, 2] <class 'list'>
七、小数据池
7.1小数据池
python中 有小数据池的概念。
int -5 ~256 的相同的数全都指向一个内存地址，节省空间。
str：s = 'a' * 20 以内都是同一个内存地址
#只要字符串含有非字母元素，那就不是一个内存地址
id查看内存空间 is比较内存空间
>>> a = 'pjh'
>>> b = 'pjh'
>>> a is b
True
>>> a == b
True
>>> print(id(a),id(b))
2684914026960 2684914026960
7.2深浅copy
赋值运算，它们共用一个列表
a = [1,2,3]
b = a
a.append(666) //a列表添加数值，b列表也会添加
print(a,b)
结果：
[1, 2, 3, 666] [1, 2, 3, 666]
7.2.1浅copy
l1 = [1,2,3]
l2 = l1.copy()
l1.append(666)
print(l1,l2)
print(id(l1),id(l2))
结果 //浅copy第一层使用不同的内存空间
[1, 2, 3, 666] [1, 2, 3]
1335989190216 1335988343688
l1 = [1,2,3]
l2 = l1.copy()
l1.append(666)
print(l1,l2)
print(id(l1),id(l2))
l1 = [1,2,3,[22,33]]
l2 = l1.copy()
l1[-1].append(666)
print(l1,l2)
print(id(l1[-1]),id(l2[-1]))
结果
[1, 2, 3, 666] [1, 2, 3]
2164139703880 2164138857352
[1, 2, 3, [22, 33, 666]] [1, 2, 3, [22, 33, 666]]
2164138879816 2164138879816
结论：
对于浅copy来说，第一层创建的是新的内存地址，而从第二层开始，
指向的都是同一个内存地址，所以，对于第二层以及更深的层数来说，保持一致性
7.3.2深copy
深copy 对于深copy来说，两个是完全独立的，改变任意一个的任何元素（无论多少层），另一个绝对不改变
import copy
l1 = [1,2,3,[22,33]]
l2 = copy.deepcopy(l1)
l1[-1].append(666)
print(l1,l2)
print(id(l1[-1]),id(l2[-1]))
结果：
[1, 2, 3, [22, 33, 666]] [1, 2, 3, [22, 33]]
2057633767176 2057633825992
