1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
# 十六进制:以0x开头
print(0x11)
print(0x111)
# 二进制
print(0b101)
print(0B101)
# 八进制
print(0o12)
print(0o23)
#
十进制转换为二进制
print(bin(3))
#
十进制转换为十六进制
print(hex(19))
# 十进制转换为八进制
print(oct(10))

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
# 小数点形式
f =
3.14
print(f)
# 3.14
print(type(f)) # <class 'float'>
# 指数形式： aEn 或 aen
'''
3.2E5 = 3.2×105，其中 3.2 是尾数，5 是指数。
2.7E-3 = 2.7×10-2，其中 2.7 是尾数，-3 是指数。
0.2E8 = 0.2×107，其中 0.2 是尾数，8 是指数。
'''
f1 =
3.2E5
print(f1)
# 320000.0
print(type(f1)) # <class 'float'>
f2 =
3.2E-5
print(f2)
# 3.2e-05
print(type(f2)) # <class 'float'>
f3 = 3.1415926123456789876543217789
print(f3)
# 双精度(double float,保留17为有效数字)
print(type(f3))

1
2
3
数据类型暗转换；在如下案例中，python不会进行数据类型的暗转换，返回False；但在js中，会将第一个1转换为字符串1再去比较，返回True；
print(1 == '1')
#False:int与str作比较，返回False；

1
2
3
4
5
#任意数据类型都有一个具体的布尔值为False，我们成为零值，该类型的其他值的布尔值为True；
print(bool("")) # 字符串的零值 “”
print(bool(0))
# 整型的零值 0
print(bool(False)) # 布尔类型的零值 False

1
2
3
4
5
6
s1 = "hi yuannhi，alvin"
print(s1)
s2 = 'I'm yuan'
print(s2)
s3 = "D:\nythonProject\nenv\Scripts\python.exe"
print(s3)

1
2
3
4
5
6
7
s = """
s = "hi yuan\nhi，alvin"
I'm yuan
这是一个python解释器路径："D:\nythonProject\nenvScriptspython.exe"
长字符串中放置单引号或者双引号不会导致解析错误
"""
print(s)

1
2
3
name = "yuan"
age = 23
print("My name is %s; My age is %d"%(name,age))

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
#位置映射
print("我是 {}，今年 {} 岁，有 {} 零花钱。".format('王老师', 38, 27.35))
#我是 王老师，今年 38 岁，有 27.35 零花钱。
#关键字映射
print("我是 {}，今年 {age} 岁，有 {} 零花钱。".format('王老师', 27.35, age = 11))
#我是 王老师，今年 11 岁，有 27.35 零花钱。
#元素访问
print("{0[0]}.{0[1]}".format(('baidu','com')))
#baidu.com
#填充与对齐
"^"代表居中
"<"代表左对齐
">"代表右对齐
print("{:*>8}".format("245"))
#*****245
#format数字精度设置
a="我是{0},我的存款有{1:.2f}"
print(a.format("煮雨",3888.4123654))
# '我是煮雨,我的存款有3888.41'

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
# （1）索引取值
s = "hello yuan"
print(s[6])
print(s[-10])
# （2）切片取值：序列类型对象[start : end : step]
step默认是1；step为正时，即从左向右切，step为负时，即从右向左切；
s = "hello yuan"
print(s[1:4]) # ell
：取索引1到索引3（左闭又开）
print(s[:4])
# hell ：start缺省，默认从0取
print(s[1:])
# ello yuan ： end缺省，默认取到最后
print(s[1:-1]) # ello yua
print(s[6:9]) # yua
print(s[-4:-1]) # yua
print(s[-1:-4]) # 空
print(s[-1:-4:-1]) #nau
step为1：从左向右一个一个取。为-1 ，从右向左一个取
# （3）判断存在：Python 中，可以使用 in 关键字检查某元素是否为序列的成员。
s = "hello yuan"
print("yuan" in s) # True
# （4）支持两种类型相同的序列使用“+”运算符做相加操作，它会将两个序列进行连接，但不会去除重复的元素。
#
使用数字 n 乘以一个序列会生成新的序列，其内容为原来序列被重复 n 次的结果
s = "hello"+" yuan"
print(s) # hello yuan
s= "*"*10
print(s) # **********

1
2
3
4
5
6
7
8
9
10
11
12
13
14
i = int("3")
print(i,type(i)) # 3 <class 'int'>
s = str(3.14)
print(s,type(s)) # 3.14 <class 'str'>
b1 = bool(10)
b2 = bool(0)
b3 = bool("yuan")
b4 = bool("")
b5 = bool("0")
print(b1) # True
print(b2) # False
print(b3) # True
print(b4) # False
print(b5) # True