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转义字符

 

 

在需要在字符中使用特殊字符时，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更新列表

直接赋值到列表中

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']

 

 

除此之外，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.元组

因为元组不经常使用，这里不做详细介绍

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}

 

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循环删除列表

再循环一个列表时，不要对列表进行删除的动作(改变列表元素的个数动作)，会出错

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