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 = ["","abc",""]
>>> names.extend(a)           #将两个列表扩展成一个列表
>>> names
['admin', '我是新来的', 'lily', '追加第一个', 'boy', '', 'abc', '']
>>> a                                  #列表不会改变
['', 'abc', '']

扩展

　　 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', '', 'abc', '']
>>> names.sort()                        #排序
>>> names
['', '', 'abc', 'admin', 'admin', 'admin', 'boy', 'lily', '我是新来的', '追加第一个']

排序

　　 2.2.1、翻转

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

翻转

　　 2.2.2、获取下标

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

获取下标

　　2.2.3、长度获取

>>> names
['追加第一个', '我是新来的', 'lily', 'boy', 'admin', 'admin', 'admin', 'abc', '', '']
>>> 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 = ("","","","")
>>> ages
('', '', '', '')

　　　　注：只有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 "<stdin>", line 1, in <module>
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 in info:
    print(key,info[key])

    name3 jack
    name1 lily
    name2 admin
    name4 abc

循环

六、集合

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

• 去重，把一个列表变成集合，就自动去重了
• 关系测试，测试两组数据之前的交集、差集、并集等关系

　　集合常用操作：关系运算

　　in
　　not in
　　＝＝
　　 ！＝ 不等于
　　 <,<=
　　 >,>=
　　 |,|=:合集
　　 &.&=:交集
　　 －,－=:差集
　　 ^,^=:对称差分

　set 的创建：　

　　

>>> L = [,,,,]
>>> t = (,,,,,,)
>>> s = {}
>>> type(s)
<class 'set'>
>>> s= set(L)
>>> s
{, , , }   #从列表到集合

>>> s = set(t)
>>> s
{, , , , }  #从元组到集合

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 "<input>", line 1, in <module>
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 in s
False
>>> 3 in s
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'}

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}

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

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

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

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

七、文件操作

对文件操作流程

1. 打开文件，得到文件句柄并赋值给一个变量
2. 通过句柄对文件进行操作
3. 关闭文件

模式	描述
r	打开一个文件为只读。文件指针被放置在文件的开头。这是默认模式。
rb	打开一个文件只能以二进制格式读取。文件指针被放置在文件的开头。这是默认模式。
r+	打开用于读和写文件。文件指针置于该文件的开头。
rb+	打开用于读取和写入二进制格式的文件。文件指针置于该文件的开头。
w	打开一个文件只写。如果文件存在覆盖该文件。如果该文件不存在，则创建写入新文件。
wb	打开一个文件只能以二进制格式写入。如果文件存在覆盖该文件。如果该文件不存在，则创建写入新文件。
w+	打开文件为写入和读取模式。如果文件存在覆盖现有文件。如果该文件不存在，创建用于读写操作的新文件。
wb+	打开用于以二进制格式写入和读出文件。如果文件存在覆盖现有文件。如果该文件不存在，创建用于读写操作的新文件。
a	打开用于追加的文件。文件指针是在文件是否存在该文件的末尾。也就是说，该文件是在追加模式。如果该文件不存在，它会创建一个用于写入的新文件。
ab	打开文件用于二进制格式追加。文件指针是在文件是否存在该文件的末尾。也就是说，文件是在追加模式。 如果该文件不存在，它会创建一个用于写入的新文件。
a+	打开文件为追加和读取方式。文件指针是在文件是否存在该文件的末尾。该文件以追加模式打开。如果该文件不存在，它将创建用于读写操作的新文件。
ab+	打开一个文件以附加和二进制格式读取模式。如果该文件存在文件指针在该文件的末尾。该文件以追加模式打开。如果该文件不存在，它将创建读写操作的新文件。

　　file 对象属性

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

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

　　　　属性:

	描述
file.closed	如果文件被关闭返回true，否则为false
file.mode	返回文件打开访问模式
file.name	返回文件名

　示例：

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

结果：

Name of the file: foo.txt
Closed or 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 is a 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 is
Current file position :  10
Again read String is :  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