第二章

数据类型与字符串

数据类型的表示方法：
表示数字或数值的数据类型称之为数字类型
数字类型有整型（int）、浮点型（float）、复数类型（complex）、特殊的整型——布尔类型（bool）

表示整型的方法（进制代表逢几进一）

1. 二进制（“0o”或“0b”开头），由0和1组成
2. 八进制（“0o”或“0O”开头）,由0，1，2，3，4，5，6，7组成
3. 十进制（默认表示方法），由0，1，2，3，4，5，6，7，8，9
4. 十六进制（“0x”或“0X”开头），由0，1，2，3，4，5，6，7，8，9，A，B，C，D，E，F组成

浮点数

浮点数一般以十进制形式表示，对于较大或较小的浮点数，可以是用科学计数法表示
Num_one = 3.14 # 十进制形式表示
Num_two = 2e2 # 二的二次方
Num_third = 2e-2 # 二的负二次方

复数

复数有以下三个特点：

1. 复数由实部和虚部构成，其一般形式为：real+i mag j
2. 实部real和虚部的imag都是浮点型
3. 虚部必须有后缀j或J

python中创建复数的两种方式：

1. 按照复数的一般形式直接创建
   num_one = 3+2j
2. 通过内置函数complex()创建
   num_two =complex(3,2)

布尔类型

python中的布尔类型（bool）只有两个取值：true和false

python中的任何对象都可以转换为布尔类型，若要进行转换，符合以下条件的数据都会被转换为false：

1. None;
2. 任何为0的数字类型，如0、0.0、0j
3. 任何空序列，如""、()、[]
4. 任何空字典，如{}；
5. 用户定义的类实例，如类中定义了_bool_()或者_len_()

除以上对象以外，其它的对象都会被转为True

可以使用bool()函数检测对象的布尔值

>>>bool(0)
false
>>>bool([])
false
>>>bool(2)
true

# type()函数，返回对象的**数据类型**
# 整型int，整数
num = 10  #十进制
result = tyoe(num)  # 使用result变量，保存num的数据类型
print(result)  # <class 'int'>

num1 = 0x1f  # 十六进制
print(type(num1))  # 直接使用print函数输出num1 的数据类型

# 浮点型 float，小数
pi = 3.14
print(type(pi)) # <class 'float'>  type(pi).print 回车（快捷键）

# 复数 complex
num2 = 3 + 2j
print(type(num2))  # <class 'complex'>

# bool 类型，只有两个值，true，false；true和false是关键字
print(type(true))  # <class 'bool'>
print(type(false))  # <class 'bool'>

# bool() 函数,可以检测一个对象的bool值
print(bool(0))  # false
print(bool(1))  # true

类型转换函数

python内置了一系列可实现强制类型转换的函数，保证用户在有需求的情况下，将目标数据转换为指定类型

函数	说明
int()	将浮点型、布尔类型和符合数值类型规范的字符串转换为整型
float()	将整型和符合数值类型规范的字符串转换为浮点型
str()	将数值类型转换为字符串

注意

1. int()函数、float()函数只能转换符合数字类型格式规范的字符串；
2. 使用int()函数将浮点数转换为整数时，若有必要会发生截断（取整）而非四舍五入。

# 字符串：使用引号引起来的内容就是字符串
# 类型转换函数，不会改变原有数据的类型，会产生一个新的数据
# int()转换为整型
# 1. 将浮点型转换为int类型
num1 = 3.14  # float
num2 = int(type(num2))  # <class 'int'>
num1 = int(type(num1))  # <class 'float'>

# 注意：将浮点型转换为int类型，是舍弃小数，而非四舍五入
num3 = in(3.9)
print(num3)  # 3

# 2. 将bool类型转换为int类型
# True --> 1  False --> 0
num4 = int(true)
num5 = int(false)
print(num4,type(num4))  # 1 <class 'int'>
print(num5,type(num5))  # 0 <class 'int'>

# 3. 将整数类型的字符串转换为int类型
# "4" "10"
my_str = '10'
print(type(my_str))  # <class 'str'>
num6 = int(my_str)
print(num6,type(num6))  #<class 'str'>

# 如果不是整数类型的字符串，是不能转换的
#num7 = int("3.14")  # 代码运行出错，3.14是小数类型的字符串，不是整数类型的字符串，不能转换

# 4. 将数字类型的字符串和小数类型的字符串
num9 = float('100')
print(num9,type(num9)  # 100.0 <class 'float'>
num10 = float('3.14')
print(num10,type(num10)  # 3.14 <class 'float'>

# str() 将其他类型转换为字符串类型
my_str1 = str(1)
print(my_str1,type(my_str1))  # 1 <class 'str'>

my_str2 = str(3.14)
print(my_str2,type(my_str2))  # 3.14 <class 'str'>

字符串的定义

字符串是一种用来表示文本的数据类型，它是由符号或者数值组成的一个连续序 列。

python支持使用单引号、双引号和三引号定义字符串，
单引号和双引号通常用于定义单行字符串
三引号通常用于定义多行字符串

定义字符串时单引号与双引号可以嵌套使用，注意：使用双引号表示的字符串中允许嵌套单引号，但不允许包含双引号，同上，使用单引号表示的字符串中不允许包含单引号。

#字符串的定义
#1、使用单引号定义
my_str1 = 'hello itcast'  # 绿色的下划线，认为itcast不是一个标准的单词
print(my_ser1.type(my_str1)  # hello itcase <class 'str'>

#2、使用双引号定义
my_str2 = "hello itcast"
print(my_str2,type(my_str2))  # hello itcast <class 'str'>

#3、使用三引号定义（三个单引号和三个双引号）
my_str3 = """my name isitcast
my name is itcast"""
print(my_str3,type(my_str3)

my_str4 = '''my name isitcast
my name is itcast'''
print(my_str4,type(my_str4)
#三个引号的字符串，如果不使用变量保存，也可以作为多行注释使用
"""
多行注释，不会执行
多行注释，不会执行
多行注释，不会执行行
"""
#混合使用
my_str5 = "let's go"
print(my_str5,type(my_str5))  # let's go <class 'str'>

#包括换行的字符串，\n 换行
my_str2 = "hello \nitcast"
print(my_str6)

字符串的格式化输出

python字符串可通过占位符、format()方法和f-strings三种方式实现格式化输出

占位符%
python将一个带有格式符的字符串作为模板，使用该格式符为真实值预留位置，并说明真实值应该呈现的格式。
>>> name = "李强"
>>> "你好我叫%s" % name

一个字符串可以同时包含多个占位符。
>>>name = "李强"
>>> age = 12
>>> "你好，我叫%s，今年我%d岁了。"%(name,age)
你好，我叫李强，今年我12岁了。

不同的占位符为不同类型的变量预留位置，常见的占位符如下表所示：

符号	说明
%s	字符串
%d	十进制整数
%o	八进制整数
%x	十六进制整数（a-f为小写）
%X	十六进制整数（A-F为大写）
%e	指数（底写为e）
%f	浮点数

format()方法
format方法也可以将字符串进行格式化输出，使用该方法无需再关注变量的类型。
format()方法还可以对数字进行格式化，包括保留n位小数、数字补齐和显示百分比。

f-strings
f-strings在格式上以f或F引领字符串，字符串中使用 {} 表名被格式化的变量
>>> address = '河北'
>>> f'欢迎来到{address}。'
欢迎来到河北。

使用f-strings还可以将多个变量进行格式化输出。
>>> name = '张天'
>>> age = 20
>>> gender = '男'
>>> f'我得名字是{name}，今年{age}岁了，我的性别是：{gender}。'
我的名字是张天，今年20岁了，我的性别是：男。

# % 占位符，%s str,%d int,%f float
# format {}
# f-strings {变量} python3.6 开始支持使用

# 需求1：我的名字是李强
name = '李强'
print('我的名字是%s' % name)
print('我的名字是{}'.format(name))
print(f"我的名字是{name}")

# 需求2：我的名字是李强，我的年龄是18岁
age = 18
print('我的名字是%s，我的年龄是%d' %(name,age))
print('我的名字{}，我的年龄是{}岁'.format(name,age))
print(F'我的名字是{name},我的年龄是{age}岁')

# 需求·3：pi的值是3.14
pi = 3.14
print('pi的值是%f' % pi)  # 默认输出6位小数
print('pi的值是%.2f' % pi)
print('pi的值是{}'.format(pi))
print('pi的值是{:.3f}'.format(pi))  # 保留三位小数
print('pi的值是{pi}')
print(f'pi的值是{pi:.3f}')

pi的值是3.140000
pi的值是3.14
pi的值是3.14
pi的值是3.140
pi的值是3.14
pi的值是3.140

字符串的常规操作

字符串的拼接
字符串的拼接可以直接使用 “+” 实现，示例代码：
>>> str_one = "人生苦短，"
>>> str_two = "我用python。"
>>> str_one + str_two
人生苦短，我用python。

1、字符串拼接，可以使用 + 实现，字符串 + 字符串 = 新的字符串

my_str1 = 'hello'

字符串的索引与切片

字符串是一个由元素组成的序列，每个元素所在处的位置是固定的，并且对应着一个位置编号，编号从0开始，依次递增1，位置编号被称为索引或者下标。

索引自0开始从左至右依次递增是正向索引；若索引从右至左依次递减则是反向索引。

通过索引获取指定位置的字符，语法格式：
字符串[索引]
若索引越界，程序会报索引异常。

切片
即截取目标对象中一部分的操作，语法格式为：‘
[起步：结束：步长]

切片默认步长为1。且切片选区的区间为左闭右开型，切下的子串包含起始位，但不包含结束位。

my_str={-1}.print可以直接打印

算数运算符

算数运算符包括+、-、*、/、//、%和**，这些运算符都是双目运算符，每个运算符都可以与两个操作数组成一个表达式。

python中的算术运算符支持对相同或不同类型的数字进行混合运算。

print(3 + (3+2j))  # 整型+复数--> 复数
# (6+2j)
print(3 * 4.5)  # 整型+浮点数-->浮点数
# 13.5
print(true + (1+2j))  # 布尔类型+复数-->复数
# (2+2j)

python中的强制转换：

1. 布尔类型进行算术运算时，被视为0或1
2. 整型与浮点型运算时，将整型转化为浮点型
3. 其它类型与复数运算时，将其它类型转换为复数类型

a = 10
b = 2
# / 除（python3得到的是浮点数）
result4 = a / b  # 10  / 2 = 5.0
print(result4)

# // 整除
result5 = a // b
print(result5)  # 5
print(10 // 3)  # 3

# % 取余
result6 = 10 % 3  # 1
print(result6)

# ** 幂运算
result7 = a ** b  # 10 ** 2 =100
print(result7)

比较运算符

比较运算符有：==、!=、>、<、>=、<=（都为双目运算符）。

# 比较运算符，返回的是bool类型，即返回的值是true false

#定义两个变量
a = 5
b = 3
# == 判断是否相等
result = a == b  # false
print(result)  # false
print(a == b)  # false

# != 判断是否相等
print(a != b)  # true
# > 大于
print(a > b)  # true
# < 小于
print(a < b)  # false

赋值运算符

功能：讲一个表达式或者对象给一个左值，其中左值必须是一个可修改的值，不能为一个常量

>>> a = 5
>>> b = 7
>>> a = b
print(a)
7

# 赋值运算符 = 是将等号右边的数据或者表达式给等号左边的变量
# 定义两个变量
a = 5
b = 3
c = a + b  # 8
print(c)

# 复合赋值运算符 += ， 先进行算术运算，然后将计算的结果给到左边的变量
a += b  # a = a + b  即a = 5 + 3

逻辑运算符

python中分别使用or、and、not这三个关键字作为逻辑运算“或”、“与”、“非”的运算符，其中or与and为双目运算符，not为单目运算符。

在逻辑运算符中：0就是false，其他数字就是true

or【左操作数的布尔值为true，则返回左操作数，否则返回右操作数或其计算结果】

and【左操作数的布尔值为false，则返回左操作数或其计算结果，否则返回右操作数的执行结果】

not【若操作数的布尔值为false，则返回true，否则返回false】

>>>3 or 0
3
>>>3 -3 and 5
0
>>>not(false)
true

# and 逻辑与，and连接的两个表达式的结果必须为true，整体结果为true，一假为假
result = 5-3 and 5 >3  # true and true --->true
print(result)

# or 逻辑或，or连接的两个表达式只要有一个的结果为true，整体结果就为true，一真为真
print(1 > 3 or 5 > 3)  # false or true --->true

# not 取反，即本来是true，加上not就为false
print(not(5 > 3))  # not(true) --->false

位运算符

程序中的所有数据在计算机内存中都以二进制形式储存，位运算则是以二进制为单位进行的运算。

# 位运算符，是对数字二进制位的运算
a = 2  # 0000 0010
b = 3  # 0000 0011

# << 按位左移，按照二进制形式，将二进制形式，将所有数字向左移动，高位移除（舍弃），低位补0， a << b ===> a * 2**b
print(a << 3)  # 0001 0000   16   2 * 2**3

# >> 按位右移，……，向右移动，地位移除（舍弃），高位补0.  a >> b ===> a // (2**b)
print(a >> 1)  # 0000 0001   1   2 // 2**1

# & 按位与，两个数字对应位都为1，结果为1，否则为0
print(a & b)  # 0000 0010   2

# | 按位或，两个数字对应的二进制只要有一个为1，结果就为1
print(a | b)  # 0000 0011   3

# ~ 按位取反，二进制位1，取反为0，二进制位0，取反为1，公式 ~x=-(x+1)
print(~a)  # -(2+1)  -3
print(~b)  # -(3+1)  -4
# 按位取反只变二进制的最后一位，且结果添加一个负号

位运算符优先级

默认情况下，运算符的优先级决定了复杂表达式的运算顺序，但可以用圆括号”（）“改变表达式的执行顺序。

运算符一般按照自左向右的顺序结合
但赋值运算符的结合性为自右向左: