python数据类型有空格_python 基础之数据类型

一、python中的数据类型之列表

1、列表

列表是我们最以后最常用的数据类型之一，通过列表可以对数据实现最方便的存储、修改等操作

二、列表常用操作

>切片

>追加

>插入

>修改

>删除

>扩展

>拷贝

>统计

>排序

>翻转

>>> names = ["admin","abc","jack","lily"] #定义列表

>>> names #查表中的元素

['admin', 'abc', 'jack', 'lily']

通过下标访问列表中的元素，下标从0开始计数>>>names[0]'admin'

>>> names[1]'abc'

>>> names[2]'jack'取最后一个元素：>>> names[-1]'lily'取倒数第二个元素：>>> names[-2]'jack'

2.1.1、切片：取多个元素

>>>names

['admin', 'abc', 'jack', 'lily']>>> names[0:3] #取下标0到下标3之间的数字，包括0，不包括3

['admin', 'abc', 'jack']>>> names[:3] #从头开始取，0可以忽略，跟上问效果一样

['admin', 'abc', 'jack']>>> names[0:-1] #取下标0到-1之前的数字，包括0，不包括-1.也就是最后一个

['admin', 'abc', 'jack']>>> names[1:] #如果想取到最后一个，只能这么写，不能写-1

['abc', 'jack', 'lily']>>> names[1:-1] #如果写成-1,此时不包括-1

['abc', 'jack']>>> names[0::2] #后面的2代表每隔一个元素取一个

['admin', 'jack']>>> names[::2] #跟上句效果一样

['admin', 'jack']

切片

2.1.2、追加

>>>names

['admin', 'abc', 'jack', 'lily']>>> names.append("追加第一个") #追加函数 append，默认追加到最后一个

>>>names

['admin', 'abc', 'jack', 'lily', '追加第一个']>>> names.append("追加第二个")>>>names

['admin', 'abc', 'jack', 'lily', '追加第一个', '追加第二个']

追加

2.1.3、插入

>>>names

['admin', 'abc', 'jack', 'lily', '追加第一个', '追加第二个']>>> names.insert(1,"我是新来的") #在下标1的前面插入一个元素

>>>names

['admin', '我是新来的', 'abc', 'jack', 'lily', '追加第一个', '追加第二个']>>> names.insert(-1,"我也是新来的") #在倒数第一个前面插入一个元素

>>>names

['admin', '我是新来的', 'abc', 'jack', 'lily', '追加第一个', '我也是新来的', '追加第二个']

插入

2.1.4、修改

>>>names

['admin', '我是新来的', 'abc', 'jack', 'lily', '追加第一个', '我也是新来的', '追加第二个']>>> names[6] = "boy" #将下标6的元素改为boy

>>>names

['admin', '我是新来的', 'abc', 'jack', 'lily', '追加第一个', 'boy', '追加第二个']

修改

2.1.5、删除

删除可以有三种方法实现>>>names

['admin', '我是新来的', 'abc', 'jack', 'lily', '追加第一个', 'boy', '追加第二个']>>> del names[3] #删除下标为第3个的元素 ‘蜡jack'

>>>names

['admin', '我是新来的', 'abc', 'lily', '追加第一个', 'boy', '追加第二个']>>>names

['admin', '我是新来的', 'abc', 'lily', '追加第一个', 'boy', '追加第二个']>>> names.remove("abc") #删除指定元素

>>>names

['admin', '我是新来的', 'lily', '追加第一个', 'boy', '追加第二个']>>> names.pop() #删除最后一个元素并将删除元素显示出来

'追加第二个'

>>>names

['admin', '我是新来的', 'lily', '追加第一个', 'boy']

删除

2.1.6、扩展

>>>names

['admin', '我是新来的', 'lily', '追加第一个', 'boy']>>> a = ["123","abc","321"]>>> names.extend(a) #将两个列表扩展成一个列表

>>>names

['admin', '我是新来的', 'lily', '追加第一个', 'boy', '123', 'abc', '321']>>> a #列表不会改变

['123', 'abc', '321']

扩展

2.1.7、拷贝

>>>names

['admin', '我是新来的', 'lily', '追加第一个', 'boy']>>> names_copy =names.copy()>>>names_copy

['admin', '我是新来的', 'lily', '追加第一个', 'boy']

拷贝

2.1.8、统计

>>>names

['admin', '我是新来的', 'lily', '追加第一个', 'boy', 'admin', 'admin']>>> names.count("admin") #统计列表中相同元素的个数

3

统计

2.1.9、排序

>>>names

['admin', '我是新来的', 'lily', '追加第一个', 'boy', 'admin', 'admin', '123', 'abc', '321']>>> names.sort() #排序

>>>names

['123', '321', 'abc', 'admin', 'admin', 'admin', 'boy', 'lily', '我是新来的', '追加第一个']

排序

2.2.1、翻转

>>>names

['123', '321', 'abc', 'admin', 'admin', 'admin', 'boy', 'lily', '我是新来的', '追加第一个']>>>names.reverse()>>>names

['追加第一个', '我是新来的', 'lily', 'boy', 'admin', 'admin', 'admin', 'abc', '321', '123']

翻转

2.2.2、获取下标

>>>names

['追加第一个', '我是新来的', 'lily', 'boy', 'admin', 'admin', 'admin', 'abc', '321', '123']>>> names.index("admin") #只返回找到的第一个下标

4

获取下标

2.2.3、长度获取

>>>names

['追加第一个', '我是新来的', 'lily', 'boy', 'admin', 'admin', 'admin', 'abc', '321', '123']>>> len(names) #列表中元素的个娄

10

长度获取

三、python 字符串函数

Python内置的字符串处理函数整理,收集常用的Python 内置的各种字符串处理 函数的使用方法

>>> abc = "Python String Function" #生成字符串变量

>>>abc'Python String Function'

>>> len(abc) #字符串长度获取，从0开始，包括空格在内

22

>>>abc[0]'P'

>>> abc[21]'n'

3.1、字母处理

>>>abc'Python String Function'

>>> abc.upper() #全部大写

'PYTHON STRING FUNCTION'

>>> abc.lower() #全部小写

'python string function'

>>> abc.swapcase() #大小写互换

'pYTHON sTRING fUNCTION'

>>> abc.capitalize() #首字母大写，其他小写

'Python string function'

>>> abc.title() #首字母大写

'Python String Function'

字母处理

3.2、格式化相关

>>>abc'Python String Function'

>>> abc.ljust(30，"*") #获取固定长度，左对齐，右边不够*补齐,不加*会以空格补齐

'Python String Function********'

>>> abc.rjust(30) #获取固定长度，右对齐，左边不够*补齐

'********Python String Function'

>>> abc.center(30,"*") #获取固定长度，中间对齐，两边不够用*补齐

'****Python String Function****'

格式化

3.3、搜索相关

>>>abc'Python String Function'

>>> abc.find("b") #搜索指定字符串，没有返回-1

-1

>>> abc.find("t",3) #指定起始位置搜索，返回的是第二个t的下标

8

>>> abc.find("t",1,13) #指定开始及结束位置搜索，如果找到多个，只返回第一个的下标

2

>>> abc.rfind("t") #从右边开始找

18

>>> abc.count("t") #指定字符串的个数

3上面所有方法都可用index代替，不同的是使用index查找不到会抛异常，而find返回-1

搜索相关

3.4、替换相关

>>>abc'Python String Function'

>>> abc.replace("tion","TION") #将指定字符串替换为大写

'Python String FuncTION'

>>> abc.replace("t","*",1) #替换字符串中的第一个t为*

'Py*hon String Function'

替换

3.5、去空格及去指定字符

>>> abc.strip() #去两边空格

'Python String Function'

>>> abc.lstrip() #去左边空格

'Python String Function'

>>> abc.rstrip() #去右边空格

'Python String Function'

>>> abc.strip("n") #去两边字符串，也有lstrip和rsrtip

'Python String Functio'

去空格及指定字符串

3.6、判断相关

>>>abc'Python String Function'

>>> abc.startswith("P") #是否以P开头，是则为True，不是则为False

True>>> abc.endswith("n") #是否以n结尾，是则为True,不是则为False

True>>> abc.isalnum() #是否全为字母或数字，是则为True

False>>> abc.isalpha() #是否全为字母，不是则为False,因为还有空格

False>>> abc.isdigit() #是否全为数字，不是则False

False>>> abc.islower() #是否全小写

False>>> abc.isupper() #是否全大写

False

判断

四、元组

定义：与列表类似，只不过［］改成()

特性：

1.可存放多个值

2.不可变

3.按照从左到右的顺序定义元组元素，下标从0开始顺序访问，有序

>>> ages = ("10","20","30","40")>>>ages

('10', '20', '30', '40')

注：只有2个方法，一个是count,一个是index

五、字典

定义：｛key1:value1,key2:value2｝,key-value结构，key必须可hash

字典一种key - value 的数据类型

语法：

>>> info ={

..."stu1":{"lily":{"age":18,"job":"IT"}},

..."stu2":{"jack":{"age":20,"job":"IT"}},

..."stu3":{"admin":{"age":30,"job":"Driver"}}

... }>>>info

{'stu2': {'jack': {'age': 20, 'job': 'IT'}}, 'stu1': {'lily': {'age': 18, 'job': 'IT'}}, 'stu3': {'admin': {'age': 30, 'job': 'Driver'}}}

字典的特性：

dict是无序的

key必须是唯一的,天生去重

5.1、增加

>>> info["abc"] = {"age":22,"job":"IT"}>>>info

{'stu2': {'jack': {'age': 20, 'job': 'IT'}}, 'stu1': {'lily': {'age': 18, 'job': 'IT'}}, 'abc': {'age': 22, 'job': 'IT'}, 'stu3': {'admin': {'age': 30, 'job': 'Driver'}}}

增加

5.2、修改

>>> info["abc"] = "xiaoming"

>>>info

{'stu2': {'jack': {'age': 20, 'job': 'IT'}}, 'stu1': {'lily': {'age': 18, 'job': 'IT'}}, 'abc': 'xiaoming', 'stu3': {'admin': {'age': 30, 'job': 'Driver'}}}

修改

5.3、删除

>>>info

{'stu2': {'jack': {'age': 20, 'job': 'IT'}}, 'stu1': {'lily': {'age': 18, 'job': 'IT'}}, 'abc': 'xiaoming', 'stu3': {'admin': {'age': 30, 'job': 'Driver'}}}>>> del info["abc"]>>>info

{'stu2': {'jack': {'age': 20, 'job': 'IT'}}, 'stu1': {'lily': {'age': 18, 'job': 'IT'}}, 'stu3': {'admin': {'age': 30, 'job': 'Driver'}}}>>>

#另一种方法

>>> info.pop("stu3")

{'admin': {'age': 30, 'job': 'Driver'}}>>>info

{'stu2': {'jack': {'age': 20, 'job': 'IT'}}, 'stu1': {'lily': {'age': 18, 'job': 'IT'}}}

删除

5.4、查找

>>>info

{'stu2': {'admin': {'age': 30, 'job': 'Driver'}}, 'stu1': {'lily': {'age': 18, 'job': 'IT'}}, 'stu3': {'jack': {'age': 20, 'job': 'IT'}}}>>> "stu3" in info #显示返回值

True>>> info["stu3"] #第二种方法

{'jack': {'age': 20, 'job': 'IT'}}>>> info["stu4"] #如果没找到会报错

Traceback (most recent call last):

File"", line 1, in KeyError:'stu4'

>>> info.get("stu3") #第三种方法

{'jack': {'age': 20, 'job': 'IT'}}>>> info.get("stu4") #没找到不会报错

>>>

查找

其他方法：

>>>info.values()

dict_values([{'admin': {'age': 30, 'job': 'Driver'}}, {'lily': {'age': 18, 'job': 'IT'}}, {'jack': {'age': 20, 'job': 'IT'}}])>>>info.keys()

dict_keys(['stu2', 'stu1', 'stu3'])>>> a = {1:2,2:3,"a":"b"}>>>info.update(a)>>>info

{'stu1': {'lily': {'job': 'IT', 'age': 18}}, 1: 2, 2: 3, 'stu2': {'jack': {'job': 'IT', 'age': 20}}, 'stu3': {'admin': {'job': 'Driver', 'age': 30}}, 'a': 'b'}>>>info.items()

dict_items([('stu1', {'lily': {'job': 'IT', 'age': 18}}), (1, 2), (2, 3), ('stu2', {'jack': {'job': 'IT', 'age': 20}}), ('stu3', {'admin': {'job': 'Driver', 'age': 30}}), ('a', 'b')])

其他方法

循环、、、

info ={"name1":"lily","name2":"admin","name3":"jack","name4":"abc"}for key ininfo:print(key,info[key])

name3 jack

name1 lily

name2 admin

name4 abc

循环

六、集合

集合是一个无序的，不重复的数据组合，它的主要作用如下：

去重，把一个列表变成集合，就自动去重了

关系测试，测试两组数据之前的交集、差集、并集等关系

集合常用操作：关系运算

in

not in

＝＝

！＝ 不等于

>,>=

|,|=:合集

&.&=:交集

－,－=:差集

^,^=:对称差分

set 的创建：

>>> L = [1,1,2,4,3]>>> t = (2,3,4,6,6,6,7)>>> s = {1}>>>type(s)

>>> s= set(L)>>>s

{1, 2, 3, 4} #从列表到集合>>> s = set(t)>>>s

{2, 3, 4, 6, 7} #从元组到集合

set 基本函数与操作：

s.add( x ) 将元素 x 添加到集合s中，若重复则不进行任何操作

>>> s = {1,2,"a"}>>> s.add("b")>>>s

{1, 2, 'b', 'a'}>>> s.add(1)>>>s

{1, 2, 'b', 'a'}

add

s.update( x ) 将集合 x 并入原集合s中，x 还可以是列表，元组，字典等，x 可以有多个，用逗号分开

>>>s

{1, 2, 'b', 'a'}>>> s.update({1,3})>>>s

{1, 2, 'b', 3, 'a'}>>> s.update([1,4])>>>s

{1, 2, 'b', 3, 4, 'a'}

update

s.discard( x )将 x 从集合s中移除，若x不存在，不会引发错误

>>>s

{1, 2, 'b', 3, 4, 'a'}>>> s.discard(1)>>>s

{2, 'b', 3, 4, 'a'}>>> s.discard(1)>>>s

{2, 'b', 3, 4, 'a'}

discard

s.remove( x ) 将 x 从集合s中移除，若x不存在，会引发错误

>>>s

{2, 'b', 3, 4, 'a'}>>> s.remove("a")>>>s

{2, 'b', 3, 4}>>> s.remove("a")

Traceback (most recent call last):

File"", line 1, in KeyError:'a'

remove

s.pop() 随机删除并返回集合s中某个值，注意，因为set是无序的，不支持下标操作，没有所谓的最后一个，pop()移除随机一个元素，这和其他数据结构不同

>>>s

{2, 'b', 3, 4}>>>s.pop()2

>>>s

{'b', 3, 4}

pop

s.clear() 清空

len(s) set支持len操作

>>>s

{'b', 3, 4}>>>len(s)3

x in s  set同样支持in操作

>>>s

{'b', 3, 4}>>> 1 ins

False>>> 3 ins

True

s.union( x ) 返回s与集合x的交集，不改变原集合s，x 也可以是列表，元组，字典。

>>> s1 = {1,2,3}>>> s2 = {"a","b"}>>>s1.union(s2)

{1, 2, 3, 'b', 'a'}>>>s1

{1, 2, 3}>>>s2

{'b', 'a'}

View Code

s.intersection( x ) 返回s与集合x的并集，不改变s， x 也可以是列表，元组，字典。

>>> s1 = {1,2,3}>>> s2 = {2,3,4}>>>s1.intersection(s2)

{2, 3}>>>s1

{1, 2, 3}

intersection

s.symmetric_difference( x ) 返回s和集合x的对称差集，即只在其中一个集合中出现的元素，不改变集合s， x 也可以是列表，元组，字典。

>>>s1

{1, 2, 3}>>>s2

{2, 3, 4}>>>s1.symmetric_difference(s2)

{1, 4}>>>s1

{1, 2, 3}

View Code

s.issubset( x ) 判断 集合s 是否是 集合x 子集

s.issuperset( x ) 判断 集合x 是否是集合s的子集

>>> s1 = {1,2,3}>>> s2 = {1,3}>>>s2.issubset(s1)

True>>>s1.issubset(s2)

False>>>s1.issuperset(s2)

True

View Code

求交集，并集，差集，对称差集的另一种方法：

>>> s1 = {1,2,3,"a"}>>> s2 = {3,4,"b"}>>> s1 & s2 #交集

{3}>>> s1 | s2 #并集

{1, 2, 3, 'b', 4, 'a'}>>> s1 - s2 #差集

{1, 2, 'a'}>>> s1 ^ s2 #对称差集

{1, 'b', 2, 4, 'a'}

View Code

{ } 在布尔运算中表示 False，其他均为 True

七、文件操作

对文件操作流程

打开文件，得到文件句柄并赋值给一个变量

通过句柄对文件进行操作

关闭文件

模式描述

r

打开一个文件为只读。文件指针被放置在文件的开头。这是默认模式。

rb

打开一个文件只能以二进制格式读取。文件指针被放置在文件的开头。这是默认模式。

r+

打开用于读和写文件。文件指针置于该文件的开头。

rb+

打开用于读取和写入二进制格式的文件。文件指针置于该文件的开头。

w

打开一个文件只写。如果文件存在覆盖该文件。如果该文件不存在，则创建写入新文件。

wb

打开一个文件只能以二进制格式写入。如果文件存在覆盖该文件。如果该文件不存在，则创建写入新文件。

w+

打开文件为写入和读取模式。如果文件存在覆盖现有文件。如果该文件不存在，创建用于读写操作的新文件。

wb+

打开用于以二进制格式写入和读出文件。如果文件存在覆盖现有文件。如果该文件不存在，创建用于读写操作的新文件。

a

打开用于追加的文件。文件指针是在文件是否存在该文件的末尾。也就是说，该文件是在追加模式。如果该文件不存在，它会创建一个用于写入的新文件。

ab

打开文件用于二进制格式追加。文件指针是在文件是否存在该文件的末尾。也就是说，文件是在追加模式。如果该文件不存在，它会创建一个用于写入的新文件。

a+

打开文件为追加和读取方式。文件指针是在文件是否存在该文件的末尾。该文件以追加模式打开。如果该文件不存在，它将创建用于读写操作的新文件。

ab+

打开一个文件以附加和二进制格式读取模式。如果该文件存在文件指针在该文件的末尾。该文件以追加模式打开。如果该文件不存在，它将创建读写操作的新文件。

file 对象属性

一旦文件被打开，则就会有一个文件对象，你就可以得到有关该文件的各种信息。

这里是一个文件对象相关的所有属性的列表：

属性:

描述

file.closed

如果文件被关闭返回true，否则为false

file.mode

返回文件打开访问模式

file.name

返回文件名

示例：

1 fo = open("foo.txt","wb")2 print("Name of the file:",fo.name)3 print("Closed or not :",fo.closed)4 print("Opening mode:",fo.mode)5 fo.close()

结果：

Name of the file: foo.txt

Closedor not: False

Opening mode: wb

close()方法

文件对象的close()方法用于刷新任何未写入的信息，并关闭文件对象， 之后就没有更多的写入东西了。

Python自动关闭文件当参考文件对象分配给另一个文件。使用 close()方法关闭文件一个很好的做法。

fileObject.close();

示例：

fo = open("foo.txt","wb")print("Name of the file:",fo.name)

fo.close()

结果：

Name of the file: foo.txt

读写文件

文件对象提供了一组访问方法。 我们将看到如何使用 read()和write()方法来读取和写入文件。

write() 方法

write()方法将字符串写入一个打开的文件。要注意，Python的字符串可以是二进制数据，而不仅仅只是文字。

write()方法不添加换行符('\n')到字符串的结尾-

语法：

fileObject.write(string);

这里，传递的参数是要写入到打开的文件的内容。

示例：

fo = open("foo.txt","w")

fo.write("Python is a great language.\n Yeah its great!\n")

fo.close()

上面的方法将创建 foo.txt 文件，并给出的内容写入文件，最后将关闭该文件。如果打开这个文件，会看到它有以下内容。

Python isa great language.

Yeah its great!

read() 方法

read()方法从一个打开的文件读取字符串。要注意，Python字符串可以是二进制数据。而并非只是文本数据。

语法

fileObject.read([count]);

这里，传递的参数是从打开的文件读取的字节数。该方法开始从文件的开始读取，并且如果 count丢失，那么它会尝试尽可能读，也许直到文件的末尾。

示例

让我们使用一个文件 foo.txt，这是我们在上面所创建的。

#Open a file

fo = open("foo.txt", "r+")

str= fo.read(10)print ("Read String is :", str)#Close opened file

fo.close()

这将产生以下结果 -

Read String is : Python is

文件位置

tell() 方法告诉你该文件中的当前位置；换句话说，下一个读或写将发生在从该文件的开头之后多个字节。

seek(offset[, from]) 方法改变当前文件的位置。offset 参数指示要移动字节数。from 参数指定字节从哪移动的参考位置。

如果 from 被设置为0，这意味着使用该文件的开头作为基准位置，以及如果设置为1，则使用当前位置作为基准位置，如果它被设置为2，则该文件的结束将被作为基准位置。

示例

让我们使用一个文件foo.txt，这是我们在上面创建的。

#Open a file

fo = open("foo.txt", "r+")

str= fo.read(10)print ("Read String is :", str)#Check current position

position =fo.tell()print ("Current file position :", position)#Reposition pointer at the beginning once again

position =fo.seek(0, 0)

str= fo.read(10)print ("Again read String is :", str)#Close opened file

fo.close()

这将产生以下结果 -

Read String is : Python isCurrent file position :10Again read Stringis : Python is

重命名和删除文件

Python的os模块提供了执行文件处理操作，如重命名和删除文件的方法。

要使用这个模块，需要先导入它，然后就可以调用任何相关的功能了。

八. 字符编码与转码

详细文章:

http://www.cnblogs.com/yuanchenqi/articles/5956943.html

http://www.diveintopython3.net/strings.html

需知:

1.在python2默认编码是ASCII, python3里默认是utf-8

2.unicode 分为 utf-32(占4个字节),utf-16(占两个字节)，utf-8(占1-4个字节)， so utf-8就是unicode

3.在py3中encode,在转码的同时还会把string 变成bytes类型，decode在解码的同时还会把bytes变回string