3-1內建型态

 Python 当中，所有东西都是一个物件。物件可以当作是 Python 当中的最小单位，所以接下来要介绍的内建资料型态，都可以是物件。Python 的内建型态主要分为以下三种：

数值型态：int, float, bool
字串型态：str, chr
容器型态：list, dict, tuple

• Niklaus E. Writh 曾说过：Algorithms + Data Structures = Programs
• 在 Python 中所有的资料都是物件

3-1-1. 数值型态

3-1-1-1.整数

• 整数
– 型态为 int，不再区分整数与长整数
– Python3以后，整数型态为int，整数的长度不受限制（除了硬体上的限制之外）

接下來展示8, 10, 16 進位

>>> 10
10
>>> 0b1010
10
>>> 0o12
10
>>> 0xA
10

如果想知道int物件好用了多少位元組, 可以透過sys模組的getsizeof()函式

import sys

print(sys.getsizeof(43848947982))

#输出结果为32

Python3.6之后，可使用"_"区隔数字，增加可读性。

>>> 1_000_000_000
1000000

如果想知道资料型态，可以使用type()函式：

如下[code01]

x = 10
print(x)
print(type(x))

y = 20.0
print(y)
print(type(y))


#输出结果
'''
10
<class 'int'>
20.0
<class 'float'>
'''

任何数使用int()函式将转换成整数，布林值的True会转成1，False会转成0：

x = 3
print(int(x))
y = 3.14159
print(int(y))
z = False
print(int(False))


#输出结果
'''
3
3
0
'''

浮点数型态 float()：

x = float(3.14159)
print(x)
print(int(float(3.14159)))

#输出结果
'''
3.14159
3
'''

布林型态:

布林型态的值只有两个，True与False，为bool型态

如下：非0值传True，反之传回False

＊: None, False, complex, ' '空字串, () 空tuple, [ ]空清单, { }空字典传给bool都会传回False，其余则传回True

x = bool(True)
print(int(x))
y = bool(False)
print(int(y))
z = 16
print(bool(z))
ab = 0
print(bool(ab))
cd = -13
print(bool(cd))


#输出结果
'''
1
0
True
False
True

'''

复数(complex)：

撰写时使用 a+bj的形式

x = 5 + 6j
y = 7 + 3j
print(x + y)
print(type(x + y))

#输出结果
'''
(12+9j)
<class 'complex'>
'''

3-1-2. 字串型态

如果要在Python表示字串可以使用單引號' '或雙引號" "包住文字，假设字串要使用单引号，则外面包住文字的引号要使用双引号，反之使用单引号，或着使用我们稍后会使用到的符号来解决问题。

"Jame's"
'jame"s'

基本字串表示：

如上所示，假设文字内都要使用单引号与双引号可以使用字串转译，如下

print('Jame\'s')
print("Jame\"s")

#Jame's
#Jame"s

下列为字串转译表示方式：

\\	反斜线。
\'	单引号，使用' '来表示字串，又要表示单引号时使用，例如：'Jame\'s'。
\"	双引号，使用" "来表示字串，又要表示单引号时使用，例如："Jame\"s"。
\ooo	以8进位数字表示字元码点，最多3位数，例如：'\101'表示字串'A'。
\xhh	以16进位数字hh表示字元码点，例如：'\x41'表示字串'A'。
\uhhhh	以16进位数字hhhh表示字元码点。
\Uhhhhhhhh	以16进位数字hhhhhhhh表示字元码点。
\0	空字元。
\n	換行。
\r	归位。
\t	Tab。

想要表示\t，就必須撰寫'\\t'，這或許有些不方便，此時可以在字串前加上r。

print('\\t')
print(r'\t')

'''
\t
\t
'''

旧式字串格式化

资料形式：String % Data 

('string' % (d1, d2))

如下所示：.3f的3为输出结果为结果取到小数点第3位

print('Hi %s' % 'Jason')
print('%d ÷ %d = %.3f' % (10, 3, 10 / 3))

'''
Hi Jason
10 ÷ 3 = 3.333
'''

以下为常用格式化符号

%%	%符号已经作为控制符号，如果要在字串表示%，必须使用%%
%f	十进位浮点数
%d	十进位整数
%g	十进位整数或浮点数
%e, %E	科学记号输出，分别为小写输出与大写输出
%o	8进位整数
%x, %X	16进位整数输出，分别为小写输出与大写输出
%s	字串格式符号
%r	以repr()函式获取的结果输出字串，稍后章节会更详细介绍repr()函式

可以使用+, -符号来决定字串靠右对齐或靠左对齐

x = 10
y = 3
print('%-5d ÷ %-5d = %8.2f' % (x, y, x / y))
print('%5d ÷ %5d = %8.2f' % (x, y, x / y))


'''
10    ÷ 3     =     3.33
   10 ÷     3 =     3.33
'''

新式字串格式化：

旧式格式化可读性差，建议使用新式，如下范例

＊注意第二行，使用数字从0开始

print('{} ÷ {} = {}'.format(10, 3, 10 / 3))
print('{0} ÷ {1} = {2}'.format(10, 3, 10 / 3))
print('{x} ÷ {y} = {z}'.format(x = 10, y = 3, z = 10 / 3))



'''
10 ÷ 3 = 3.3333333333333335
10 ÷ 3 = 3.3333333333333335
10 ÷ 3 = 3.3333333333333335
'''

无论是使用上面第二行还是第三行的方式，都可以指定型态，也可指定栏位宽度与小数点数量

第三行与第四行的< , >是决定向左对齐或向右对齐。

第五行的 ^ 符号前面可以加上要填住空白的符号。

print('{0:6d} ÷ {1:6d} = {2:8.2f}'.format(10, 3, 10 / 3))
print('{x:6d} ÷ {y:6d} = {z:8.2f}'.format(x = 10, y = 3, z = 10 / 3))
print('{0:<6d} ÷ {1:<6d} = {2:<8.2f}'.format(10, 3, 10 / 3))
print('{0:>6d} ÷ {1:>6d} = {2:>8.2f}'.format(10, 3, 10 / 3))
print('{x:?^6d} ÷ {y:&^6d} = {z:8.2f}'.format(x = 10, y = 3, z = 10 / 3))


'''
    10 ÷      3 =     3.33
    10 ÷      3 =     3.33
10     ÷ 3      = 3.33    
    10 ÷      3 =     3.33
??10?? ÷ &&3&&& =     3.33
'''

format方法也可以进行些简单运算，像是使用索引取得清单元素值，使用键名称获取字典中对应的值，或存储模组中的名称：

names = ['James', 'Curry', 'Kevin']
print('EveryNames => {p[0]}, {p[1]}, {p[2]}'.format(p = names))

import sys
print('My MacOS is {pc.platform}'.format(pc = sys))



'''
EveryNames => James, Curry, Kevin
My MacOS is darwin
'''

单一格式化输出：

print(format(1.123456, '.2f'))


'''
1.12
'''

字串格式化实字：

从Python3.6开始，撰写字串实字时以f或F作为前置，就可以进行字串格式，f-strings:

name = 'James'
print(f'Hi, {name}')
print(f'3 x 4 = {3 * 4}')
print(f'{{}}')



'''
Hi, James
3 x 4 = 12
{}
'''

f-strings也可以做运算，例如if...else运算式，函式呼叫等都可以。例如：

（不易读不建议使用）

name = None
print(f'Hi', {"James!" if name == None else name})


'''
Hi {'James!'}
'''

3-1-3容器型态：

清单(list):

清单的型态是list，特性为有序，具备索引，内容与长度可以变动。建立串列可以使用[ ]实字：

x = [1, 2, 3]
print(x)
print(x[0])
print(x[1])
print(x[2])
x[1] = 40
print(x[1])
del x[0]
print(x)


'''
[1, 2, 3]
1
2
3
40
[40, 3]
'''

可以使用[ ]建立长度为0的list，可以对list使用append()   pop()   sort()   reverse()   remove()等方法

，若要附加多个元素可以使用extend()方法，例如x.extend([1, 2, 3])，想复制list，可使用copy()函式。

集合(set):

集合的內容無序，元素不重複。要建立集合，可以使用()包括元素：

如果要建立空集合，不是使用()，因为这会建立空的dict，而不是set，若想建立空集合，必须使用set()。新增元素，可以使用add()方法，移除元素可使用remove()方法，测试元素是否在内，可使用in方法。

names = set()
names.add('James')
names.add('Curry')
print(names)
names.remove('James')
print(names)
print('James' in names)
print('Curry' in names)


'''
{'Curry', 'James'}
{'Curry'}
False
True
'''

也可以使用先前说的copy()，若要合并set，可以使用update()。

x1 = {'你', '好'}
x2 = {'你', '是'}
a = x1.copy()
a.update(x2)
print(a)


'''
{'你', '是', '好'}
'''

字典(dict)：

字典用来储存两两对应的键值：

_id = {'James' : 31, 'Curry' : 30}
print(_id['James'])
print(_id['Curry'])
_id['Kevin'] = 19
print(_id)
del _id['James']
print(_id)


'''
31
30
{'James': 31, 'Curry': 30, 'Kevin': 19}
{'Curry': 30, 'Kevin': 19}
'''

items():

_id = {'James' : 31, 'Curry' : 30}
print(list(_id.items()))
print(list(_id.keys()))
print(list(_id.values()))


'''
[('James', 31), ('Curry', 30)]
['James', 'Curry']
[31, 30]
'''

使用Dict来建立字典：

_id = dict(James = 31, Curry = 30, Kevin = 19)
print(_id)
_id = dict.fromkeys(['James', 'Curry'], 'NBA')
print(_id)

'''
{'James': 31, 'Curry': 30, 'Kevin': 19}
{'James': 'NBA', 'Curry': 'NBA'}
'''

也可以使用先前说的copy()，若要合并dict，可以使用update()。

x1 = {'a' : 1, 'b' : 2}
x2 = {'b' : 2.1, 'c' : 3}
y = x1.copy()
y.update(x2)
print(y)

'''
{'a': 1, 'b': 2.1, 'c': 3}
'''

Tuple：

Tuple跟list也是有很多地方很像喔！ ！是有序结构，可以使用[ ] 指定索引获得元素。

有时想要传回一组相关的值，又不想特别定义一个型态，就会使用Tuple。

data = 29, 'Curry', False
number, name, verified = data
print(data)
print(number)
print(name)
print(verified)

'''
(29, 'Curry', False)
29
Curry
False
'''

可将Tuple中的元素拆解，分配给每个Variable。

ant = 30, 'Curry', bool
print(ant)
print(type(ant))

'''
(30, 'Curry', <class 'bool'>)
<class 'tuple'>
'''

number, name, verified = [29, 'Curry', False]
print(number)
print(name)
print(verified)

'''
29
Curry
False
'''

3-2. 运算子

3-2-1. 运算子+ - * /

print(0.1 + 0.1 + 0.1)
print(1.0 - 0.8)


'''
0.30000000000000004
0.19999999999999996
'''

开发人员基本上要知道 IEEE 754 浮点数 算术标准，不使用小数点，而是使用分数及指数来表 示小数：
– 0.5 以 1/2 来表示
– 0.75 以 1/2+1/4 来表示 – 0.875 以 1/2+1/4+1/8
– 0.1 是1/16+1/32+1/256+1/512 +1/4096+1/8192+...没有止境

使用decimal.Decimal类别解决上面问题：

import decimal

y1 = decimal.Decimal((input()))
y2 = decimal.Decimal((input()))

print(f'{y1} + {y2} = {y1 + y2}')
print(f'{y1} - {y2} = {y1 - y2}')
print(f'{y1} * {y2} = {y1 * y2}')
print(f'{y1} / {y2} = {y1 / y2}')


'''
1
0.8
'''

'''
1 + 0.8 = 1.8
1 - 0.8 = 0.2
1 * 0.8 = 0.8
1 / 0.8 = 1.25
'''

次方**：

print(2 ** 3)
print(5 ** 5)
print(3 ** 0.5)


'''
8
3125
1.7320508075688772
'''

除法/   //：

print(10 / 3)
print(10 // 3)
print(10 // 3.0)


'''
3.3333333333333335
3
3.0
'''

结合字串应用：

str1 = 'James'
str2 = 'Curry'
print(str1 + str2)
print(str1 * 5 + str2 * 2)


'''
JamesCurry
JamesJamesJamesJamesJamesCurryCurry
'''

print('20' + str(1))
print(int('9') + 6)


'''
201
15
'''

list, tuple应用：

x1 = ['apple', 'group']
x2 = ['Kevin', 'Xiang']
print(x1 + x2)
print(x2 * 2 + x1 * 2)


'''
['apple', 'group', 'Kevin', 'Xiang']
['Kevin', 'Xiang', 'Kevin', 'Xiang', 'apple', 'group', 'apple', 'group']
'''

x1 = ['apple', 'group']
x2 = ['Kevin', 'Xiang']
y = (x1, x2)
print(y)


'''
(['apple', 'group'], ['Kevin', 'Xiang'])
'''

3-2-2. 比较运算子：

• – >、>=、<、<=、==、!=、<>

• <>效果与!=相同，不过建议不要再用

x1 = input()
x2 = input()

print(f'"{x1}" > "{x2}"  ? {x1 > x2}')
print(f'"{x1}" < "{x2}"  ? {x1 < x2}')
print(f'"{x1}" = "{x2}"  ? {x1 == x2}')
print(f'"{x1}" != "{x2}"  ? {x1 != x2}')


'''
6
5
"6" > "5"  ? True
"6" < "5"  ? False
"6" = "5"  ? False
"6" != "5"  ? True
'''

指定运算子：

+=	a += b	a = a + b
-=	a -= b	a = a - b
*=	a *= b	a = a * b
/=	a /= b	a = a / b
%=	a %= b	a = a % b
&=	a &= b	a = a & b
|=	a |= b	a = a | b
^=	a ^= b	a = a ^ b
>>=	a >>= b	a = a >> b
<<=	a <<= b	a = a << b

3-2-3. 逻辑运算子

*且   and

*或   or

*相反   not

x1 = input()
x2 = input()

print('两数是否为大写？', x1.isupper() and x2.isupper())
print('一数是否为大写？', x1.isupper() or x2.isupper())
print('两数都不是大写？', not (x1.isupper() or x2.isupper()))


'''
a
D
两数是否为大写？ False
一数是否为大写？ True
两数都不是大写？ False
'''

3-2-4. &(AND) |(OR) ^(XOR) ~(补数)运算子

（博主懒得写，很重要还是要学会）

3-2-5. 切片运算子

name = 'Kevinjay'
print(name[0:2])
print(name[2:])
print(name[:3])
print(name[:])
print(name[:-2])
print(name[-4:-1])

'''
Ke
vinjay
Kev
Kevinjay
Kevinj
nja
'''

x = 1, 2, 3, 4, 5
print(x[0:2])
print(x[1:])
print(x[:4])
print(x[-5:-1])
print(x[::-1])


'''
(1, 2)
(2, 3, 4, 5)
(1, 2, 3, 4)
(1, 2, 3, 4)
(5, 4, 3, 2, 1)
'''

3-2-6. 拆解运算子* **

#tuple
a, *b = (1, 2, 3, 4, 5)
print(a)
print(b)
print() #換行

#list
a, *b, c = (1, 2, 3, 4, 5)
print(a)
print(b)
print(c)
print()

#set
a, *b = {1, 2, 3}
print(a)
print(b)
print()

#range
a, *b, c = range(5)
print(a)
print(b)
print(c)
print()

#dict
a, *b = {'x' : 1, 'y' : 2, 'z' : 3}
print(a)
print(b)




'''
1
[2, 3, 4, 5]

1
[2, 3, 4]
5

1
[2, 3]

0
[1, 2, 3]
4

x
['y', 'z']
'''

x1 = {'你', '好'}
x2 = {'你', '是'}
y = {*x1, *x2}
print(y)


'''
{'是', '好', '你'}
'''

dict想得出键与值使用**，只要得出键使用* ：

x1 = {'a' : 1, 'b' : 2}
x2 = {'b' : 3, 'c' : 4}
y1 = {*x1, *x2}
y2 = {**x1, **x2}
print(y1)
print(y2)


'''
{'c', 'a', 'b'}
{'a': 1, 'b': 3, 'c': 4}
'''