阿础的冒险之旅

第二集

目录：

  1. 数据类型转换
  2. py的注释
  3. 运算符的运用

一.数据类型转换：

A.隐式类型转换

  1. 在隐式类型转换中，Python 会自动将一种数据类型转换为另一种数据类型;我们对两种不同类型的数据进行运算，较低数据类型（整数）就会转换为较高数据类型（浮点数）以避免数据丢失
1
2
3
4
5
6
7
num_int = 223    #数据类型为：<class 'int'>
num_str = "492"  # 数据类型为: <class 'float'>

print("num_int 数据类型为:",type(num_int))
print("num_str 数据类型为:",type(num_str))

print(num_int+num_str)

从输出中可以看出，整型和字符串类型运算结果会报错，输出 TypeError。 Python 在这种情况下无法使用隐式转换。

但是，Python 为这些类型的情况提供了一种解决方案，称为显式转换.

B.显式类型转换

  1. 在显式类型转换中，用户将对象的数据类型转换为所需的数据类型。 我们使用 int()、float()、str() 等预定义函数来执行显式类型转换

    int(),float(),str()的强制转换：

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    y = int(4.8) # y 输出结果为 4
    z = int("8") # z 输出结果为 8

    x = float(1) # x 输出结果为 1.0
    y = float(2.4)   # y 输出结果为 2.4
    z = float("9")   # z 输出结果为 9.0

    x = str("s1") # x 输出结果为 's1'
    y = str(2)    # y 输出结果为 '2'
    z = str(3.0)  # z 输出结果为 '3.0'

    整型和字符串类型进行运算时，就可以用强制类型转换来完成：

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    num_int = 99
    num_str = "352"

    print("num_int 数据类型为:",type(num_int))
    print("类型转换前，num_str 数据类型为:",type(num_str))

    num_str = int(num_str)    # 强制转换为整型
    print("类型转换后，num_str 数据类型为:",type(num_str))

    num_sum = num_int + num_str

    print("num_int 与 num_str 相加结果为:",num_sum)
    print("sum 数据类型为:",type(num_sum)

    Type是一个空接口，所有类型的公共接口（父接口),,type()函数是Python内置的函数之一，它用于获取一个对象的数据类型

二. python注释

分为 # ， ‘ ’ ， “ ” ，三种。

#：单行注释

在 Python 中，多行注释是由三个单引号 ‘’’ 或三个双引号 “”” 来定义的，而且这种注释方式并不能嵌套使用。

当你开始一个多行注释块时，Python 会一直将后续的行都当作注释，直到遇到另一组三个单引号或三个双引号。

错误例子：

1
2
3
4
5
6
7
8
9
10

'''
这是外部的多行注释
可以包含一些描述性的内容

    '''
    这是尝试嵌套的多行注释
    会导致语法错误
    '''
'''

如果需要在注释中包含嵌套结构，推荐使用单行注释（以#开头）而不是多行注释。

单行注释可以嵌套在多行注释中，而且不会引起语法错误。

合法的例如：

1
2
3
4
5
6
7
'''
这是外部的多行注释
可以包含一些描述性的内容

# 这是内部的单行注释
# 可以嵌套在多行注释中
'''

三. 运算符

  1. python算数运算符

简单的有：+，- , * , / ,

% 取模 - 返回除法的余数,

** 幂 - 返回x的y次幂

// 取整除 - 往小的方向取整数

  1. python比较运算符

以下假设变量 a 为 10，变量 b 为20：

运算符 描述 实例
== 等于 - 比较对象是否相等 (a == b) 返回 False。
!= 不等于 - 比较两个对象是否不相等 (a != b) 返回 True。
> 大于 - 返回x是否大于y (a > b) 返回 False。
< 小于 - 返回x是否小于y。所有比较运算符返回1表示真，返回0表示假。这分别与特殊的变量True和False等价。注意，这些变量名的大写。 (a < b) 返回 True。
>= 大于等于 - 返回x是否大于等于y。 (a >= b) 返回 False。
<= 小于等于 - 返回x是否小于等于y。 (a <= b) 返回 True。

3 .python赋值运算

就是个一个变量设值，进行运算。

海象运算符： 它使用 := 符号。这个运算符的主要目的是在表达式中同时进行赋值和返回赋值的值。

使用海象运算符可以在一些情况下简化代码，在需要在表达式中使用赋值结果的情况下。这对于简化循环条件或表达式中的重复计算很有用。

海象：

1
2
3
4
5
6
7
8
# 传统写法
n = 10
if n > 5:
    print(n)

# 使用海象运算符
if (n := 10) > 5:
    print(n)
  1. if (n := 10) > 5: ：这是使用海象运算符（:=）的写法。海象运算符在表达式中进行赋值操作。
  • (n := 10)：将变量 n 赋值为 10，同时返回这个赋值结果。
  • > 5：检查赋值后的 n 是否大于 5。如果条件为真，则执行接下来的代码块。
  1. print(n)：如果条件为真，打印变量 n 的值（即 10）。
  • 传统写法需要单独一行来赋值 n，然后在 if 语句中进行条件检查。而使用海象运算符的写法可以在 if 语句中直接进行赋值和条件检查。
  1. python逻辑算符

Python语言支持逻辑运算符，以下假设变量 a 为 10, b为 20:

运算符 逻辑表达式 描述 实例
and x and y 布尔”与” - 如果 x 为 False，x and y 返回 x 的值，否则返回 y 的计算值。 (a and b) 返回 20。
or x or y 布尔”或” - 如果 x 是 True，它返回 x 的值，否则它返回 y 的计算值。 (a or b) 返回 10。
not not x 布尔”非” - 如果 x 为 True，返回 False 。如果 x 为 False，它返回 True。 not(a and b) 返回 False
  1. Python成员运算符

除了以上的一些运算符之外，Python还支持成员运算符，测试实例中包含了一系列的成员，包括字符串，列表或元组。

运算符 描述 实例
in 如果在指定的序列中找到值返回 True，否则返回 False。 x 在 y 序列中 , 如果 x 在 y 序列中返回 True。
not in 如果在指定的序列中没有找到值返回 True，否则返回 False。 x 不在 y 序列中 , 如果 x 不在 y 序列中返回 True。

成员运算符：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
#!/usr/bin/python3
 
a = 10
b = 20
list = [1, 2, 3, 4, 5 ]
 
if ( a in list ):
   print ("1 - 变量 a 在给定的列表中 list 中")
else:
   print ("1 - 变量 a 不在给定的列表中 list 中")
 
if ( b not in list ):
   print ("2 - 变量 b 不在给定的列表中 list 中")
else:
   print ("2 - 变量 b 在给定的列表中 list 中")
 
# 修改变量 a 的值
a = 2
if ( a in list ):
   print ("3 - 变量 a 在给定的列表中 list 中")
else:
   print ("3 - 变量 a 不在给定的列表中 list 中")
  1. Python身份运算符

身份运算符用于比较两个对象的存储单元

运算符 描述 实例
is is 是判断两个标识符是不是引用自一个对象 x is y, 类似 id(x) == id(y) , 如果引用的是同一个对象则返回 True，否则返回 False
is not is not 是判断两个标识符是不是引用自不同对象 x is not y ， 类似 **id(x) != id(y)**。如果引用的不是同一个对象则返回结果 True，否则返回 False。

例如：

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
#!/usr/bin/python3
 
a = 20
b = 20
 
if ( a is b ):
   print ("1 - a 和 b 有相同的标识")
else:
   print ("1 - a 和 b 没有相同的标识")
 
if ( id(a) == id(b) ):
   print ("2 - a 和 b 有相同的标识")
else:
   print ("2 - a 和 b 没有相同的标识")
 
# 修改变量 b 的值
b = 30
if ( a is b ):
   print ("3 - a 和 b 有相同的标识")
else:
   print ("3 - a 和 b 没有相同的标识")
 
if ( a is not b ):
   print ("4 - a 和 b 没有相同的标识")
else:
   print ("4 - a 和 b 有相同的标识")

is 与 == 区别：

is 用于判断两个变量引用对象是否为同一个， == 用于判断引用变量的值是否相等