Python基础数字、字符串、列表、元组、字典

Number（数字）---> int、float、complex（复数）

在Python3中，整形(int)就是常见的整数：1，100，500，1000......

浮点型(float)，就是我们常见的用小数点表示的小数，例如0.5， 1.2， 3.14，等等。

复数（complex, 复数由实数部分和虚数部分构成，可以用a + bj,或者complex(a,b)表示，复数的实部a和虚部b都是浮点型。

属性	描述
num.real	该复数的实数部分
num.imag	该复数的虚数部分
num.conjugat()	返回该复数的共轭算数

n = '123'
print(type(n))
m = int(n)
print(type(m))
num = '101'
a = int(num, base=2)
b = int(num, base=8)
c = int(num, base=10)  # 等同 int(num)
d = int(num, base=16)
print(a)
print(b)
print(c)

执行结果：

<class 'str'>
<class 'int'>
5
65
101
257

String（字符串）--->str

class str

---*---传送门---*---

Python中的字符串用单引号(')或双引号(")括起来，同时使用反斜杠(\)转义特殊字符，加号 (+) 是字符串的连接符，星号 (*) 表示复制当前字符串，紧跟的数字为复制的次数。

input接收的值默认为str类型，使用type()可以返回一个数据类型。

s = 'lcgSmile'
s1 = s.capitalize()  # 首字母大写。
print(s1)
s2 = s.casefold()  # 字符串全输出为小写 相比lower()能识别更多不限于ASCII(A-Z)字符。
print(s2)
s3 = s.center(20, '-')   # 原字符串居中,填充至一定长度的新字符串，默认填充字符为空格。
print(s3)
s4 = s.endswith('e')  # 判断字符串是否以指定后缀结尾，如果以指定后缀结尾返回True
print(s4)
s5 = s.find('c')  # 查找子串在字符串的开始位置。
print(s5)
s6 = s.index('g')  # 如果包含子字符串返回开始的索引值，否则抛出异常。
print(s6)

执行结果：

Lcgsmile
lcgsmile
------lcgSmile------
True
1
2

索引

 +---+---+---+---+---+---+
 | P | y | t | h | o | n |
 +---+---+---+---+---+---+
   0   1   2   3   4   5
  -6  -5  -4  -3  -2  -1

List（列表）--->list

class list

列表对象方法的清单：

`list.append`(x)

添加一个元素到列表的末尾。相当于 a[len(a):] = [x].

`list.extend`(L)

将给定列表L中的所有元素附加到原列表a的末尾。相当于 a[len(a):] = L.

`list.insert`(i, x)

在给定位置插入一个元素。第一个参数为被插入元素的位置索引，因此 a.insert(0, x) 在列表头插入值， a.insert(len(a), x)相当于 a.append(x).

`list.remove`(x)

删除列表中第一个值为 x 的元素。如果没有这样的元素将会报错。

`list.pop`([i])

删除列表中给定位置的元素并返回它。如果没有给定位置，a.pop()将会删除并返回列表中的最后一个元素。（i 两边的方括号表示这个参数是可选的，而不是要你输入方括号。你会在 Python 参考库中经常看到这种表示法)。

`list.clear`()

删除列表中所有的元素。相当于 del a[:].

`list.index`(x)

返回列表中第一个值为 x 的元素的索引。如果没有这样的元素将会报错。

`list.count`(x)

返回列表中 x 出现的次数。

`list.sort`(key=None, reverse=False)

排序列表中的项 (参数可被自定义, 参看 sorted() ).

`list.reverse`()

列表中的元素按位置反转。

`list.copy`()

返回列表的一个浅拷贝。相当于 a[:].

列表方法示例：

>>> a = [66.25, 333, 333, 1, 1234.5]
>>> print(a.count(333), a.count(66.25), a.count('x'))
2 1 0
>>> a.insert(2, -1)
>>> a.append(333)
>>> a
[66.25, 333, -1, 333, 1, 1234.5, 333]
>>> a.index(333)
1
>>> a.remove(333)
>>> a
[66.25, -1, 333, 1, 1234.5, 333]
>>> a.reverse()
>>> a
[333, 1234.5, 1, 333, -1, 66.25]
>>> a.sort()
>>> a
[-1, 1, 66.25, 333, 333, 1234.5]
>>> a.pop()
1234.5
>>> a
[-1, 1, 66.25, 333, 333]

你可能已经注意以下方法 insert、 remove 或 sort 只修改列表且没有可打印的返回值 — — 他们返回默认 None。这是Python里可变数据结构的设计原则。

`del` 语句

有一个方法可以根据索引而不是值从列表中删除一个元素：del语句。这跟pop()方法不同，后者会返回一个值。del语句也可以用于从列表中删除片段或清除整个列表（先前我们通过将一个空列表赋值给这个片段来达到此目的）。例如：

>>> a = [-1, 1, 66.25, 333, 333, 1234.5]
>>> del a[0]
>>> a
[1, 66.25, 333, 333, 1234.5]
>>> del a[2:4]
>>> a
[1, 66.25, 1234.5]
>>> del a[:]
>>> a
[]

del 也可以用于删除整个变量︰

>>> del a

如果再次对变量a进行引用将引起错误（至少在对变量a再次赋值前）。

Tuple（元组）--->tuple

class tuple

元组其实跟列表差不多，也是存一组数，只不是它一旦创建，一级元素不能再修改，所以又叫只读列表。

构造包含0个或1个元素的元组：空的元组通过一对空的圆括号构造；只有一个元素的元组通过一个元素跟随一个逗号构造

>>> empty = ()
>>> singleton = 'hello',
>>> len(empty)
0
>>> len(singleton)
1
>>> singleton
('hello',)

它只有2个方法，一个是count,一个是index，用法跟列表用法相似。可以通过迭代访问其中的元素。

Dictionary（字典）--->dict

class dict

另一个有用的Python内置数据类型是字典（映射类型）。与由数字索引的序列不同，字典是依据键索引的，键可以是任意不可变的类型；字符串和数字始终能作为键。元组可以用作键，如果它们只包含字符串、数字或元组；如果一个元组直接或间接地包含任何可变对象，它不能用作键。不能使用列表作为键，因为列表可以使用索引赋值、切片赋值或append()和extend()方法在原变量上修改。

理解字典的最佳方式是把它看做无序的键:值对集合，要求是键必须是唯一的（在同一个字典内）。一对空的花括号创建一个空的字典：{}。将用逗号分隔的键:值对序列放置在花括号中将添加初始的键:值对到字典中；这也是字典写到输出中的方式。

字典的主要操作是依据键来存取值。还可以通过del删除一个键:值对。如果你用一个已经存在的键存储值，那么以前为该键分配的值就会被覆盖。从一个不存在的键中读取值会导致错误。

访问字典里的值

通过键访问（访问不存在的键会报错）

d = {'a': ('a',), 'b': 'ab', 7: 'ab'}
print(d[7]), print(d['a'])

ab
('a',)

删除字典元素

删单一的元素（del命令）也能清空字典（dict.clear()）

d = {'a': ('a',), 'b': 'ab', 7: 'ab'}
del d['a'],
print(d)

{7: 'ab', 'b': 'ab'}

d = {'a': ('a',), 'b': 'ab', 7: 'ab'}
d.clear()
print(d)

{}

字典内置的魔法

序号	函数及描述
1	.clear() 删除字典内所有元素
2	.copy() 返回一个字典的浅复制
3	dict.fromkeys(seq[, value])) 创建一个新字典，以序列seq中元素做字典的键，val为字典所有键对应的初始值
4	dict.get(key, default=None) 返回指定键的值，如果值不在字典中返回default值
5	key in dict 如果键在字典dict里返回true，否则返回false
6	dict.items() 以列表返回可遍历的(键, 值) 元组数组
7	dict.keys() 以列表返回一个字典所有的键
8	dict.setdefault(key, default=None) 和get()类似, 但如果键不存在于字典中，将会添加键并将值设为default
9	dict.update(dict2) 把字典dict2的键/值对更新到dict里
10	dict.values() 以列表返回字典中的所有值

.clear()

d1 ={1: 2, 3: 4, 5: 6}
d1.clear()
print(d1)

{}

.copy()

d1 ={1: 2, 3: 4, 5: 6}
d2 = d1.copy()
print(d2)

{1: 2, 3: 4, 5: 6}

dict.fromkeys(seq[,vase])

seq -- 字典键值列表。
value -- 可选参数, 设置键序列（seq）的值。

t = ('a', 'b', 'c')
d1 = dict.fromkeys(t)
print(d1)
d2 = dict.fromkeys(t, 'e')
print(d2)

{'b': None, 'a': None, 'c': None}
{'b': 'e', 'a': 'e', 'c': 'e'}

.get(key, default=None)

返回指定键的值，如果值不在字典中返回默认值。

key -- 字典中要查找的键。
default -- 如果指定键的值不存在时，返回该默认值值。

d1 ={1: 2, 3: 4, 5: 6}
i = d1.get(1)
v = d1.get(2,100)
n = d1.get('a')
print(i), print(v), print(n)

2
100
None

.items()

item()方法把字典中每对key和value组成一个元组，并把这些元组放在列表中返回。

d1 ={1: 2, 3: 4, 5: 6}
v =d1.items()
print(v)

dict_items([(1, 2), (3, 4), (5, 6)])

此方法常配合for...in...用于字典的遍历

for key,value in dict.items():

print (key,value)

d1 ={1: 2, 3: 4, 5: 6}
for k, v in d1.items():
    print(k, v)

1 2
3 4
5 6

.key()

字典 keys() 方法以列表返回一个字典所有的键。

d1 = {1: 2, 3: 4, 5: 6}
v = d1.keys()
print(v)

dict_keys([1, 3, 5])

.setdefault()

字典 setdefault() 方法和get()方法类似, 如果键不已经存在于字典中，将会添加键并将值设为默认值。

key -- 查找的键值。
default -- 键不存在时，设置的默认键值。

d1 = {1: 2, 3: 4, 5: 6}
d1.setdefault(7)
d1.setdefault(8, 9)
print(d1)

{8: 9, 1: 2, 3: 4, 5: 6, 7: None}

d_shou.update(d_chuan)

字典 update() 函数把字典d_chuan的键/值对更新到d_shou里。

d1 = {1: 2, 3: 4, 5: 6}
d2 = {'a': 'b', 'c': 'd'}
d1.update(d2)
print(d1), print(d2)

{1: 2, 3: 4, 5: 6, 'c': 'd', 'a': 'b'}
{'c': 'd', 'a': 'b'}

.values

字典 values() 方法以列表返回字典中的所有值。

d1 = {1: 2, 3: 4, 5: 6}
v = d1.values()
print(v)

dict_values([2, 4, 6])