Python基础

 

1、数字

int（整型）

　　在32位机器上，整数的位数为32位，取值范围为-2**31～2**31-1，即-2147483648～2147483647
　　在64位系统上，整数的位数为64位，取值范围为-2**63～2**63-1，即-9223372036854775808～9223372036854775807
long（长整型）
　　跟C语言不同，Python的长整数没有指定位宽，即：Python没有限制长整数数值的大小，但实际上由于机器内存有限，我们使用的长整数数值不可能无限大。
　　注意，自从Python2.2起，如果整数发生溢出，Python会自动将整数数据转换为长整数，所以如今在长整数数据后面不加字母L也不会导致严重后果了。
float（浮点型）
　　浮点数用来处理实数，即带有小数的数字。类似于C语言中的double类型，占8个字节（64位），其中52位表示底，11位表示指数，剩下的一位表示符号。
complex（复数）
　　复数由实数部分和虚数部分组成，一般形式为x＋yj，其中的x是复数的实数部分，y是复数的虚数部分，这里的x和y都是实数。
注：Python中存在小数字池：-5 ～ 257  

2、布尔值

　　真或假
　　1 或 0
　　True 或 False

3、字符串

基本操作：

# 1.字符串长度
a='hello world'
print len(a)   # 11

# 2、字符串中字母大小写转换
a = 'HELLO WORLD'
print a.lower()  # 转换为小写 hello world
a = 'hello world'
print a.upper()  # 转换为大写 HELLO WORLD
a='hello world'
print a.capitalize() # 首字母大写 Hello world
a = 'Hello World'
print a.swapcase() # 大小写互换 hELLO wORLD

# 3.将字符串放入中心位置可指定长度以及位置两边字符
a = 'hello world'
print a.center(20,'-')             # ----hello world-----
print len('----hello world-----')  # 20

# 4.删除空白
# str.strip()：删除字符串两边的空格
a = '   hello   '
b = a.strip()
print b
# str.lstrip():删除字符串左边空格
a = '   hello'
b = a.lstrip()
print b
# str.rstrip():删除字符串右边的空格
a = 'hello   '
b = a.rstrip()
print b

# 5.分割:前中后三部分
a = 'hello world'
print a.partition(' ')  # ('hello', ' ', 'world')
print a.partition('o')  # ('hell', 'o', ' world')

# 6.复制字符串
a = 'hello'
b = a
print a,b     # hello hello

# 7.字符串拼接
# A. +：拼接2个字符串
a = 'hello '
b = 'world'
print a + b    # hello world
注：此方法又称为 "万恶的加号",因为使用加号连接2个字符串会调用静态函数string_concat(register PyStringObject *a ,register PyObject * b)，
在这个函数中会开辟一块大小是a+b的内存的和的存储单元，然后将a,b字符串拷贝进去。如果是n个字符串相连，那么会开辟n-1次内存，是非常耗费资源的。

# B. str.join:连接2个字符串,可指定连接符号
a = ["hello", "world"]
b = "******".join(a)
print b        # hello******world
a = ("hello", "world")
b = "######".join(a)
print b        # hello######world

# 8.查找字符串(检测字符串中是否包含子字符串str，可指定范围)
# str.index 和str.find 功能相同，区别在于find()查找失败会返回-1，不会影响程序运行。一般用find!=-1或者find>-1来作为判断条件。
a = 'hello world'
print a.index('w')   # 6
print a.index('x')   # ValueError: substring not found
a = 'hello world'
print a.find('w')   # 6
print a.find('x')   # -1

# 9.是否包含指定字符串(in |not in)
a = 'hello world'
if 'hello' in a:
    print 'in'
if 'qwe' not in a:
    print 'not in'

# 10. 字符串统计
a = 'hello world'
print a.count('l')  # 3

# 11.字符串的测试、判断函数 结果是布尔型
# startswith() 以...开头
print 'Hello World'.startswith('H') # True
print 'hello world'.startswith('A') # False
# endswith() 以...结尾
print 'Hello World'.endswith('d') # True
print 'hello world'.endswith('D') # False
# islower() 字符串中的字母是否全是小写
print 'Hello World'.islower() # False
print 'hello world'.islower() # True
# isupper() 字符串中字母是否全是大写
print 'Hello World'.isupper() # False
print 'hello world'.isupper() # False
# istitle()是否是首字母大写的(会对每个进行判断)
print 'Hello World'.istitle() # True
print 'Hello world'.istitle() # False

# 12.字符串切片(顾头不顾尾)
使用一对方括号、起始偏移量start、终止偏移量end 以及可选的步长step 来定义一个分片。
格式： [start:end:step]
[:] 提取从开头（默认位置0）到结尾（默认位置-1）的整个字符串
[start:] 从start 提取到结尾
[:end] 从开头提取到end - 1
a = '0123456789'
print a[0:3]     #截取第一位到第三位的字符（0可省，等价于 print a[:3]）
print a[:]       #截取字符串的全部字符
print a[6:]      #截取第七个字符到结尾
print a[:-3]     #截取从头开始到倒数第三个字符之前
print a[2]       #截取第三个字符
print a[-1]      #截取倒数第一个字符
print a[::-1]    #字符串倒序
print a[-3:-1]   #截取倒数第三位与倒数第一位之前的字符
print a[-3:]     #截取倒数第三位到结尾
print a[:-5:-3]  #逆序截取，截取倒数第五位数与倒数第三位数之间

# 13.切割
a = 'hello world'
print a.split(' ')  # ['hello', 'world']
print a.split('o')  # ['hell', ' w', 'rld']

# 14.替换
a = 'hello world'
print a.replace(' ', 'my') # hellomyworld
print a.replace('hello', 'my') # my

# 15.根据换行执行分割
a = 'hello
world'
print a.splitlines()  # ['hello', 'world']
# 16.索引：str[下标]
a = 'hello world'
print a[0] # 从0开始

列表和元组的主要不同在于：列表是可以修改的，而元组不可以。
Python支持一种数据结构的基本概念，名为容器（container）。容器基本上就是可包含其他对象的对象。两种主要的容器是序列（如列表和元组）和映射（如字典）。在序列中，每个元素都有编号，而在映射中，每个元素都有名称（也叫键）。

4、列表

基本操作：

# 1.索引(第一个索引是0，第二个是1，以此类推)，可以使用索引来获取元素，这种索引方式适用于所有序列。
当你使用负数索引时，Python将从右（即最后一个元素）开始往左数，因此-1是最后一个元素的位置。
可以直接对其执行索引操作，无需先将其赋给变量。
my_list = ['a', 'b', 'c', 'd', 'e']
print my_list[0]   # a
print my_list[3]   # d

# 2.切片
my_list = ['a', 'b', 'c', 'd', 'e']
print my_list[1:]      # 除了第一个元素之外的其他元素     ['b', 'c', 'd', 'e']
print my_list[:-1]     # 除了最后一个元素之外的其他元素   ['a', 'b', 'c', 'd']
# 列表的翻转
# 方式一：
print my_list[::-1]    # ['e', 'd', 'c', 'b', 'a']
# 方式二：
my_list.reverse()
print my_list          # ['e', 'd', 'c', 'b', 'a']

# 3.重复
my_list = ['a', 'b', 'c', 'd', 'e']
print my_list * 2              # ['a', 'b', 'c', 'd', 'e', 'a', 'b', 'c', 'd', 'e']

# 4.连接
my_list1 = ['a', 'b', 'c', 'd', 'e']
my_list2 = ['a', 'b', 'c', 'd', 'e']
print my_list1 + my_list2      # ['a', 'b', 'c', 'd', 'e', 'a', 'b', 'c', 'd', 'e']

# 5.是否包含(in |not in)
my_list = ['a', 'b', 'c', 'd', 'e']
print 'a' in my_list        # True
print 'a' not in my_list    # False

# 6.遍历
my_list = ['a', 'b', 'c', 'd', 'e']
for i in my_list:
    print i
# a
# b
# c
# d
# e

# 7.列表的增删改查操作

# 增加
my_list = ['a', 'b', 'c', 'd', 'e']
my_list.append('f')           # append:追加 追加一个元素到列表中(末尾位置添加)
print my_list                 # ['a', 'b', 'c', 'd', 'e', 'f']
my_list = ['a', 'b', 'c', 'd', 'e']
my_list.extend(['f', 'g'])    # extend:拉伸 追加多个元素到列表中(末尾位置添加)
print my_list                 # ['a', 'b', 'c', 'd', 'e', 'f', 'g']
my_list = ['a', 'b', 'c', 'd', 'e']
my_list.insert(1, 'bb')       # insert:在指定索引位置插入元素
print my_list                 # ['a', 'bb', 'b', 'c', 'd', 'e']

# 删除(可以用del语句、pop()方法、remove()方法进行删除。)
my_list = ['a', 'b', 'c', 'd', 'e']
del my_list[1]                # del可以删除任意已知位置的列表元素,从内存中删除列表.
print my_list                 # ['a', 'c', 'd', 'e']
# pop()可以传递索引值，也可在括号里指定索引，来删除指定位置的列表元素,如果不指定索引，默认删除最后一个元素。
my_list = ['a', 'b', 'c', 'd', 'e']
print my_list.pop()                  # e
print my_list                        # ['a', 'b', 'c', 'd']
my_list = ['a', 'b', 'c', 'd', 'e']
print my_list.pop(1)                 # b
print my_list                        # ['a', 'c', 'd', 'e']
my_list = ['a', 'b', 'c', 'd', 'e']
my_list.remove('a')                  # remove()不需要知道元素位置，根据元素的值即可删除元素。
print my_list                        # ['b', 'c', 'd', 'e']

# 修改
my_list = ['a', 'b', 'c', 'd', 'e']
my_list[0] = 'aaa'          # 通过索引，重新赋值
print my_list               # ['aaa', 'b', 'c', 'd', 'e']
my_list = ['a', 'b', 'c', 'd', 'e']
print my_list[:2]           # ['a', 'b']
my_list[:2] = ['aaa','bbb'] # 通过切片
print my_list               # ['aaa', 'bbb', 'c', 'd', 'e']

# 查看
my_list = ['a', 'b', 'c', 'd', 'e']
print my_list.count('a')    # 1 查看列表中元素出现的次数
print my_list.index('a')    # 0 查看指定元素的索引值
print my_list[0]            # a 查看指定索引的元素值

# 8.长度
my_list = ['a', 'b', 'c', 'd', 'e']
print len(my_list)          # 5
# 9.排序
my_list = ['d', 'c', 'b', 'a', 'e']
my_list.reverse()           # reverse列表反转排序：是把原列表中的元素顺序从左至右的重新存放，而不会对列表中的参数进行排序整理。
print my_list               # ['e', 'a', 'b', 'c', 'd']

# sort排序方法是直接修改原列表list排序方法。
my_list = ['d', 'c', 'b', 'a', 'e']
my_list.sort()              # 正序排序
print my_list               # ['a', 'b', 'c', 'd', 'e']
my_list = ['d', 'c', 'b', 'a', 'e']
my_list.sort(reverse=True)  # 倒序排序
print my_list               # ['e', 'd', 'c', 'b', 'a']

# sorted()方法即可以保留原列表，又能得到已经排序好的列表。
my_list = ['d', 'c', 'b', 'a', 'e']
print sorted(my_list)       # ['a', 'b', 'c', 'd', 'e']
print my_list               # ['d', 'c', 'b', 'a', 'e']　

5、元组

基本操作：

# 1.特性
# 元组如果只有一个元素的时候，后面一定要加逗号，否则数据类型不确定
my_tuple1 = ('a')
my_tuple2 = ('a',)
print type(my_tuple1), type(my_tuple2)
# <type 'str'> <type 'tuple'>

# 2.拼接元组
my_tuple1 = ('a', 'b', 'c', 'd', 'e')
my_tuple2 = ('a', 'b', 'c', 'd', 'e')
print my_tuple1 + my_tuple1     # ('a', 'b', 'c', 'd', 'e', 'a', 'b', 'c', 'd', 'e')

# 3.重复
my_tuple = ('a', 'b', 'c', 'd', 'e')
print my_tuple * 2              # ('a', 'b', 'c', 'd', 'e', 'a', 'b', 'c', 'd', 'e')

# 4.len 求元组的元素个数
my_tuple = ('a', 'b', 'c', 'd', 'e')
print(len(my_tuple))            # 5

# 5.in| not 判断是否包含元素

# 6.元组的增删改查操作(元组本身不能增删改查，但是如果元组里面包含可变数据类型，可以间接修改元组的内容)
my_tuple = ('a', ['b', 'c'], 'd', 'e')
# my_tuple[0] = 'aa' 如此执行会报错
my_tuple[1][0] = 'bb'
print my_tuple    # ('a', ['bb', 'c'], 'd', 'e')

my_tuple = ('a', ['b', 'c'], 'd', 'e')
my_tuple[1].append('cc')
print my_tuple    # ('a', ['b', 'c', 'cc'], 'd', 'e')

my_tuple = ('a', ['b', 'c'], 'd', 'e')
my_tuple[1].remove('c')
print my_tuple    # ('a', ['b'], 'd', 'e')

# 7.计算，max，min，sum
my_tuple = ('a', 'b', 'c', 'd', 'e')
print(max(my_tuple))  # e
print(min(my_tuple))  # a
# sum 注意如果元组里面不是全是数值是无法求和的

# 8.排序和反转，不支持：sort()，reverse()，支持：sorted()
my_tuple = ('d', 'c', 'b', 'a', 'e')
print sorted(my_tuple)        # ['a', 'b', 'c', 'd', 'e']
print my_tuple                # ('d', 'c', 'b', 'a', 'e')
# 注：不改变元组中元素的位置，只是临时排序，是可以的

# 9.查找，index
my_tuple = ('a', 'b', 'c', 'd', 'e')
print(my_tuple.index('a'))     # 0

# 10.统计出现的次数 count
my_tuple = ('a', 'b', 'c', 'd', 'e')
print(my_tuple.count('a'))     # 1

6、字典（无序）

基本操作：

注：
# 字典中的 key 不允许重复
# 在使用 {} 创建字典时，{} 应包含多个 key-value 对，key 与 value 之间用英文冒号隔开；多个 key-value 对之间用英文逗号隔开。

字典的基本用法
# 应牢记字典包含多个 key-value 对，而 key 是字典的关键数据，因此程序对字典的操作都是基于 key 的。基本操作如下：
# 1.通过 key 访问 value 。
my_dict = {'a': 1, 'b': 2, 'c': 3}
print my_dict['a']                    # 1

# 注 没有添加，有修改
# 2.通过 key 添加 key-value 对。
my_dict = {'a': 1, 'b': 2, 'c': 3}
my_dict['d'] = 4
print my_dict                         # {'a': 1, 'c': 3, 'b': 2, 'd': 4}

# 3.通过 key 修改 key-value 对。
my_dict = {'a': 1, 'b': 2, 'c': 3}
my_dict['a'] = 11
print my_dict                         # {'a': 11, 'c': 3, 'b': 2}

# 4.通过 key 删除 key-value 对。
my_dict = {'a': 1, 'b': 2, 'c': 3}
del my_dict['a']
print my_dict                         # {'c': 3, 'b': 2}

# 5.通过 key 判断指定 key-value 对是否存在(in | not in)。
my_dict = {'a': 1, 'b': 2, 'c': 3}
print 'd' in my_dict                  # False
print 'd' not in my_dict              # True

字典的常用方法
# 1.字典由 dict 类代表，因此我们可使用 dir(dict) 来查看该类包含哪些方法。

# 2.clear()方法: clear() 用于清空字典中所有的 key-value 对，对一个字典执行 clear() 方法之后，该字典就会变成一个空字典。
my_dict = {'a': 1, 'b': 2, 'c': 3}
# # 清空 my_dict 所有 key-value 对
my_dict.clear()
print my_dict              # {}

# 3.get()方法: get() 方法其实就是根据 key 来获取 value，它相当于方括号语法的增强版，当使用方括号语法访问并不存在的 key 时，字典会引发 KeyError 错误；
# 但如果使用 get() 方法访问不存在的 key，该方法会简单地返回 None，不会导致错误。
my_dict = {'a': 1, 'b': 2, 'c': 3}
# # 获取'a'对应的 value
print my_dict.get('a')     # 1
print my_dict.get('d')     # None
# print my_dict['d']       # KeyError

# 4.update()方法: update() 方法可使用一个字典所包含的 key-value对 来更新己有的字典。
# 在执行 update() 方法时，如果被更新的字典中己包含对应的 key-value 对，那么原 value 会被覆盖；如果被更新的字典中不包含对应的 key-value 对，则该 key-value 对被添加进去。
my_dict1 = {'a': 1, 'b': 2, 'c': 3}
my_dict2 = {'d': 4, 'e': 5, 'f': 6}
my_dict1.update(my_dict2)
print my_dict1             # {'a': 1, 'c': 3, 'b': 2, 'e': 5, 'd': 4, 'f': 6}

my_dict1 = {'a': 1, 'b': 2, 'c': 3}
my_dict2 = {'a': 4, 'b': 5, 'f': 6}
my_dict1.update(my_dict2)
print my_dict1             # {'a': 4, 'c': 3, 'b': 5, 'f': 6}
# 从上面的执行过程可以看出，由于被更新的 dict 中己包含 key 为'a'与'b'的 key-value 对，因此更新时该 key-value 对的 value 将被改写；
# 但如果被更新的 dict 中不包含 key 为'f'的 key-value 对，那么更新时就会为原字典增加一个 key-value 对。

# 5.items()、keys()、values() : 分别用于获取字典中的所有 key-value 对、所有 key、所有 value。如下代码示范了这三个方法的用法：
my_dict = {'a': 1, 'b': 2, 'c': 3}
# 获取字典所有的key-value对
ims = my_dict.items()
print ims                  # [('a', 1), ('c', 3), ('b', 2)]
print type(ims)            # <type 'list'>

# 获取字典所有的key
my_dict = {'a': 1, 'b': 2, 'c': 3}
kys = my_dict.keys()
print kys                  # ['a', 'c', 'b']
print type(kys)            # <type 'list'>

# 获取字典所有的value
my_dict = {'a': 1, 'b': 2, 'c': 3}
val = my_dict.values()
print val                  # [1, 3, 2]
print type(val)            # <type 'list'>
# 在 Python 2.x 中，items()、keys()、values() 方法的返回值本来就是列表，完全可以不用 list() 函数进行处理。当然，使用 list() 函数处理也行，列表被处理之后依然是列表。

# 6.pop方法: pop() 方法用于获取指定 key 对应的 value，并删除这个 key-value 对。如下方法示范了 pop() 方法的用法：
my_dict = {'a': 1, 'b': 2, 'c': 3}
print my_dict.pop('a')     # 1   会获取 'a' 对应的 value，并删除该 key-value 对。
print my_dict              # {'c': 3, 'b': 2}

# 7.popitem()方法: popitem() 方法用于随机弹出字典中的一个 key-value 对。
# 此处的随机其实是假的，正如列表的 pop() 方法总是弹出列表中最后一个元素，实际上字典的 popitem() 其实也是弹出字典中最后一个 key-value 对。
# 由于字典存储 key-value 对的顺序是不可知的，因此开发者感觉字典的 popitem() 方法是“随机”弹出的，但实际上字典的 popitem() 方法总是弹出底层存储的最后一个 key-value 对。
my_dict = {'a': 1, 'b': 2, 'c': 3}
print my_dict.popitem()    # ('a', 1)
print my_dict              # {'c': 3, 'b': 2}

# 8.setdefault()方法也用于根据 key 来获取对应 value 的值。但该方法有一个额外的功能，即当程序要获取的 key 在字典中不存在时，该方法会先为这个不存在的 key 设置一个默认的 value，然后再返回该 key 对应的 value。
# 总之，setdefault() 方法总能返回指定 key 对应的 value；如果该 key-value 对存在，则直接返回该 key 对应的 value；如果该 key-value 对不存在，则先为该 key 设置默认的 value，然后再返回该 key 对应的 value。

my_dict = {'a': 1, 'b': 2, 'c': 3}
# 设置默认值，该key在dict中不存在，新增key-value对
print my_dict.setdefault('d', 4)       # 4
print my_dict                          # {'a': 1, 'c': 3, 'b': 2, 'd': 4}
# # 设置默认值，该key在dict中存在，不会修改dict内容
my_dict = {'a': 1, 'b': 2, 'c': 3}
print my_dict.setdefault('c', 4)       # 3
print my_dict                          # {'a': 1, 'c': 3, 'b': 2}

# 9.fromkeys()方法使用给定的多个 key 创建字典，这些 key 对应的 value 默认都是 None；也可以额外传入一个参数作为默认的 value。该方法一般不会使用字典对象调用（没什么意义），通常会使用 dict 类直接调用。

# 使用列表创建包含2个key的字典
a_dict = dict.fromkeys(['a', 'b'])
print(a_dict)                          # {'a': None, 'b': None}
# 使用元组创建包含2个key的字典
b_dict = dict.fromkeys((13, 17))
print(b_dict)                          # {13: None, 17: None}
# 使用元组创建包含2个key的字典，指定默认的value
c_dict = dict.fromkeys((13, 17), 'good')
print(c_dict)                          # {13: 'good', 17: 'good'}