基本类型

Python数字

在Python中有3种类型的数——整数、浮点数和复数

数字类型示例说明
整数-2, 12389
999999L, ∞
0b1110, 0xabf, 0o126
python2中区分整型、长整型,长整型的整数可以 无穷大
python3中统称为整型
整型的二进制,十六进制,八进制表示法
浮点数-3.23, -52.3E-4在 python 中可以用科学计数法表示浮点数
复数-5+4j,2.3-4.6j其中-5,4为实数,j为虚数
  1. int

    python3 中只有 int(可存超长数据)

    整型进制表示法
    进制表示方法示例
    二进制以0b开头,只能包含0、1,逢2进10b11,0b12(错误的表示)
    八进制以0o开头,能包含0-7,逢8进10o11
    十六进制以0x开头,能包含0-F,逢16进10x11
    十进制直接由数字0-9组成,逢10进111

    整型进制操作

    1
    2
    3
    4
    进制转换-bin:任意进制转2进制,接收一个int,返回一个str
    进制转换-oct:任意进制转8进制,接收一个int,返回一个str
    进制转换-hex:任意进制转16进制,接收一个int,返回一个str
    进制转换-int:任意进制转10进制,接收一个int/str,返回一个int
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    # 示例
    >>> bin(10) # 10进制转2进制
    '0b1010'
    >>> bin(0o71) # 8进制转2进制
    '0b111001'
    >>> bin(0x11) # 16进制转2进制
    '0b10001'
    >>> int("10")
    10 # str 转换成 int
    >>> int("0o11",base=8) # 8进制的字符串,要指定一下
    9
    >>> int(0o11) # 8进制整型 直接转换
    9
  2. float

    float(浮点型):浮点数即带有小数点的数字

    ​ float由整数位,小数点,小数位组成,也可以用科学计数法表示,例如-3.23,-52.3E-4,6.23E12

    ​ float是不精确的

    decimal模块

    ​ Decimal类型数据是精确的小数,可以传递给Decimal整型或者字符串参数

    官方文档

    ​ float https://docs.python.org/3/library/functions.html#float

    ​ decimal https://docs.python.org/3/library/decimal.html?highlight=decimal

1
2
3
4
5
6
7
8
9
10
11
12
13
14
# 示例:浮点型数据float是不精确的
>>> i = 1
>>> i = i - 0.1
>>> i
0.9
>>> i = i - 0.1
>>> i
0.8
>>> i = i - 0.1
>>> i
0.7000000000000001
>>> i = i - 0.1
>>> i
0.6000000000000001
1
2
3
4
5
6
7
8
9
10
11
# 示例:Decimal类型数据是精确的小数,可以传递给Decimal整型或者字符串参数
>>> from decimal import getcontext, Decimal, Context
>>> mydec = Decimal.from_float(12.222)
>>> mydec
Decimal('12.2219999999999995310417943983338773250579833984375')
>>> mydec = Decimal(0.9)
>>> mydec
Decimal('0.90000000000000002220446049250313080847263336181640625')
>>> mydec = Decimal("3.14")
>>> mydec
Decimal('3.14')
  1. complex

    复数complex:复数就是实数和虚数的统称

    在数学中的表示:复数的基本形式是a+bi,其中a,b是实数,a称为实部,bi称为虚部,i是虚数单位

    complex的组成:复数由实数部分和虚数部分组成,一般形式为x+yj,其中的x是复数的实数部分,y是复数的虚数部分,这里的x和y都是实数

    1
    2
    3
    4
    5
    6
    # 示例
    >>> a = 5 + 4j
    >>> a.real
    5.0 # 存放的是浮点型
    >>> a.imag
    4.0

Python字符串

字符串:字符串是字符的序列

表示方法:单引号(‘);双引号(“);三引号(’''或”””);原样输出

符号说明示例
单引(')可引用包含双引号的字符串‘say“hello”’
双引号(“)可引用包含单引号的字符串“What’syourname?”
三号引(‘’'或”””)可引用一个多行的字符串,在三引号中可自由使用单引号和双引号‘’‘
这是多行字符
里面可包含单引号’和双引号”
’‘’
特殊标记®不使得转义字符,将字符原样输出r”hello\tworld!”
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
30
31
32
33
34
35
36
# 示例
>>> a = 'test'
>>> b = "test"
>>> a
'test'
>>> b
'test'
>>> a = '''
... t
... e
... s
... t'''
>>> a
'\nt\ne\ns\nt'
>>> print(a)

t
e
s
t
# print(a)按照规定的格式打印输出
>>> c = "t1\nt2"
>>> c
't1\nt2'
>>> print(c)
t1
t2
>>> c = 't1\nt2'
>>> c
't1\nt2'
>>> print(c)
t1
t2
>>> c = r"t1\nt2"
>>> print(c)
t1\nt2
  • 转义字符

    ​ 转义字符是一种特殊的字符常量。转义字符以反斜线""开头,后跟一个或几个字符。转义字符具有特定的含义,不同于字符原有的意义,故称“转义”字符。

转义字符描述转义字符描述转义字符描述
\(在行尾时)续行符\n换行\oyy八进制数,yy代表的字符,例如:\o12代表换行
\\反斜杠符号\v纵向制表符\xyy十六进制数,yy代表的字符,例如:\x0a代表换行
\’单引号\t横向制表符\other其它的字符以普通格式输出
\"双引号\r回车\b退格(Backspace)
\a响铃\f换页\e转义
\000
  1. 字符串取值

    ​ 下标取值法(注意:下标从0开始)

    ​ 切片取值法

1
2
3
4
5
6
7
# 示例
>>> a = "test"
>>> a[0]
't'
>>> a = "test"
>>> a[0:2] # 取下标为0~2的数据。包括0,不包括2
'te' # 前面包括,后面不包括

字符串的不可变的序列

一旦创造了一个字符串,就不能再改变它

1
2
3
4
5
6
7
8
# 示例
>>> a = "hello world"
>>> a[4] = "1"
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: 'str' object does not support item assignment
>>> id(a)
140585442705648

级连字符串

如果把两个字符串相邻放着,它们会被python自动级连

1
2
3
4
# 示例
>>> info = "chen""peng"
>>> info
'chenpeng'
  1. 字符串常用方法

    1. 字符串常用方法——判断系列(True/False)
方法功能
str.isdigit()字符串中是否只包含数字
str.isnumeric()字符串中是否只包含数字(包括中文一到九等)
str.isalnum()字符串中是否只包含字母或数字
str.istitle()字符串中是否每个单词首字母大写,其他字母小写
str.isalpha()字符串中是否只包含字母(汉字会算作字母)
str.isupper()字符串中是否全为大写
str.isidentifier()字符串是否为合法标识符
str.isprintable()字符串是否为可打印字符
str.islower()字符串中是否全为小写
str.isspace()字符串中是否只包含空格(tab也算空格)
str.startswith(prefix[,start[,end]])字符串是否以某字符串开始,可以通过start和stop参数设置搜索范围
str.endswith(suffix[,start[,end]])字符串是否以某个字符串结束,可以通过start和stop参数设置搜索范围
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
# 示例
my_str = "This Is TEST!"
my_title = "This is My Title"
my_num = "123"
my_num2 = "一二三四"
my_str2 = "hello"
my_str3 = "hello123"

# 判断系列
print("判断数字", my_num.isdigit()) # 字符串中是否只包含数字
print("判断数字", my_num.isnumeric()) # 字符串中是否只包含数字(包括中文一到九等)
print("判断数字", my_num2.isdigit()) # 只能判断阿拉伯数字
print("判断数字", my_num2.isnumeric()) # 可以判断中文数字

print("判断字母:", my_str.isalpha()) # 有空格/“!”会报错 # 判断字母(汉字会算作字母)
print("判断字母数字:", my_str3.isalnum()) # 有空格会报错 # 判断字母数字

print("判断字符串是否以This开始", my_title.startswith("This"))
print("判断字符串是否以This结束", my_title.endswith("This"))

​ 2. 字符串常用方法——查找统计类

方法功能
len(string)统计字符串长度
str.index(sub[,start[,end]])显示substring在字符串中第一次出现的下标位置,没有会报错
str.find(sub[,start[,end]])查找substring,找到返回其起始位置,找不到返回-1
1
2
3
4
5
6
7
8
# 示例
# 查找统计类
my_str = "This Is TEST!"

print("长度:", len(my_str)) # 空格、!占长度
print("i 第一次出现的位置", my_str.index("i")) # 字符串“i”第一次出现的位置
print("i 第一次出现的位置", my_str.find("i")) # 字符串“i”第一次出现的位置,找不到返回-1
print("i 出现的次数", my_str.count("i"))

​ 3. 字符串常用方法——字符串转换类(返回一个新对象)

方法功能
str.upper()将字符串转换为大写
str.lower()将字符串转换为小写
str.title()将字符串中的单词首字母大写,其他字母小写
str.split(‘sep’)指定’sep’作为分隔符将字符串切割成列表,分隔符可以是任意字符(默认是空格)
‘str’.join(list)将列表用str拼接成一个大字符串
str.strip([string])去除字符串中首尾的字符串,不带参数默认去除空格
str.zfill(number)返回指定长度的字符串,原字符串右对齐,前面填充0
str.replace(‘old’,‘new’[,count])用新的字符替换老字符,还可以指定替换的个数,默认全部替换
str.capitalize()句子首字母大写
str.center(width[,fillchar])str.ljust(width[,fillchar])str.rjust(width[,fillchar])返回一个原字符串居中(靠左/靠右)对齐,width为总长度,两边用一个字符fillchar填充,如果指定的长度小于原字符串的长度则返回原字符串
str.expandtabs(number)将\t转换成number个空格
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
# 示例
# 字符串转换类
msg = " hEllo World Chen "

print("大写", msg.upper())
print("小写", msg.lower())
print("标题", msg.title())

msg2 = "root:x:0:0:root:/root:/bin/bash"
print("切割:", msg2.split(":"))
msg3 = msg2.split(":")
print("拼接:", "#".join(msg3))
print("去除首尾空白", msg.strip(), "######")
print("去除root首尾:", msg2.strip("root"))
print("字符串填充:", msg.zfill(40))
print("字符串替换", msg2.replace(":", "%"))
print("整个字符串首字母大写", msg.capitalize())
msg4 = "xxx"
print(msg4.center(50, ' '))
print(msg4.center(50, '-'))
print(msg4.ljust(50, "-"))
print(msg4.rjust(50, "-"))
  1. 字符串拼接

1
2
3
4
5
6
7
8
9
10
# 示例
# 字符串拼接(+)
>>> a = 'I' + 'Love' + 'Python'
>>> print(a)
ILovePython

#字符串拼接(join)
>>> a = ['I', 'Love', 'Python']
>>> print(''.join(a))
ILovePython
1
2
3
4
+ 与 join的效率问题
一般来说,+ 拼接 效率比 join 拼接低
+拼接,每一次出现都会在内存中开辟1个新的空间,所有效率低,比较耗时
join一次性拼接成1个大的字符串
  1. 字符串格式化

1
2
3
4
5
6
7
字符串格式化(%)
基本格式
%[(name)][flags][width].[precision]typecode
-(name):命名
-flags:+,-,''或0。+表示右对齐;-表示左对齐;''为一个空格,表示在正数的左侧填充一个空格,从而与负数对齐,0表示使用0填充
-width表示显示宽度
-precision表示小数点后精度
1
2
3
4
5
6
# 示例
# %格式化
name = "wen"
age = 18
print("姓名: %s, 年龄: %s"%(name, age))
print("姓名: %s, 年龄: %s"%(age, "wen2"))
1
2
字符串格式化(format)
{变量:[填充字符][对齐方式 <^>][宽度][格式]}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
# 示例
# format 格式化
name = "wen"
age = 18
print("format01 --> 姓名:{}, 年龄:{}".format(name, age))
print("format01 --> 姓名:{}, 年龄:{}".format(age, name))
print("format02 --> 姓名: {1}, 年龄:{0}".format(name, age))
print("format02 --> 姓名: {1}, 年龄:{0}".format(age, name))
print("format03 --> 姓名:{name1}, 年龄:{age1}".format(name1 = name, age1 = age))
print("format01 --> {0:*>10}".format(10,20)) # 注:0 第1个变量
print("format01 --> {1:*>10}".format(10,20)) # 注:1 第2个变量
print("format01 --> {1:*<10}".format(10,20)) # 注::执行 ; * 填充字符
print("format01 --> {1:*^10}".format(10,20)) # 注:^ 居中 ; 10 填充宽度10字符
print("format02 --> {0:.2f}".format(1/3,5.333))
print("format02 --> {1:06.2f}".format(1/3,5.333))
# 二进制
print("format02 --> {0:b}".format(10))
# 八进制 注:16进制是”{0:x}”.format(10)
print("format02 --> {0:o}".format(10))
# 千分位格式化
print("format02 --> {0:,}".format(123456789))
1
字符串格式化-f
1
2
3
4
5
6
7
8
9
10
11
12
13
# 示例
# f标志符 格式化
a = "I"
b = "Love"
c = "Python"
print(f"{a}{b}{c}")
#结果 ILovePython
print("{a}{b}{c}".format(a = a, b = b, c = c)) # 注:效果等同
#结果 ILovePython
print(f"{a}{b}{c:a^10}") # 注:对字符串c的操作:用“a”填充宽度10,居中
#结果 ILoveaaPythonaa
print("{a}{b}{c:a^10}".format(a = a, b = b, c = c)) # 注:效果等同
#结果 ILoveaaPythonaa

Python数字-Booleans

1
2
3
4
5
6
7
布尔值(Booleans)是一个逻辑值
取值范围只有True和False(真和假)
布尔值为假:
'',0,0.0,(),[],{},None,False
None是一个特殊的常量,表示一种特殊的数据类型(NoneType)
值布尔值为真:
除了为假的,其他的都为真
1
2
3
4
5
6
7
8
9
10
11
12
13
# 示例
* 布尔值可以相互加减
>>> a = 1
>>> b = 2
>>> print(a == b)
False
>>> c = (a == b) + (a == d) # 注:c = 0 +1
>>> c
1
# 布尔值排序
>>> lst=[(a==d),(a==b)] # 注:(a==d)为真,(a==b)为假
>>> sorted(lst)
[False, True] # 注:因为默认情况下 0为假,1为真

Others

1
2
3
4
5
○常量
常量是指一旦初始化后就不能修改的固定值
注意:在Python中表示一个常量通常用大写(约定俗成,非强制)表示,如:PI=3.1415926
○NoneType
None表示什么也没有