标签：10 型态 运算子 James x2 print x1 Curry Python3.9

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

标签：10,型态,运算子,James,x2,print,x1,Curry,Python3.9
来源： https://blog.csdn.net/qq_52607733/article/details/120186104

本站声明： 1. iCode9 技术分享网（下文简称本站）提供的所有内容，仅供技术学习、探讨和分享；
2. 关于本站的所有留言、评论、转载及引用，纯属内容发起人的个人观点，与本站观点和立场无关；
3. 关于本站的所有言论和文字，纯属内容发起人的个人观点，与本站观点和立场无关；
4. 本站文章均是网友提供，不完全保证技术分享内容的完整性、准确性、时效性、风险性和版权归属；如您发现该文章侵犯了您的权益，可联系我们第一时间进行删除；
5. 本站为非盈利性的个人网站，所有内容不会用来进行牟利，也不会利用任何形式的广告来间接获益，纯粹是为了广大技术爱好者提供技术内容和技术思想的分享性交流网站。