基本数据类型与基本运算符

【昨日回顾】

【一】基本数据类型

我们学习变量是为了让计算机能够像人一样去记忆事物的某种状态
- 而变量的值就是用来存储事物状态的，很明显事物的状态分成不同种类的（比如人的年龄，身高，职位，工资等等）
- 所以变量值也应该有不同的类型，例如

salary = 3.1 		# 用浮点型去记录薪资 
age = 18     		# 用整型去记录年龄 
name = 'lili'   # 用字符串类型去记录人名

【1】数字类型

（1）整形（int）

(1.1)作用

用来记录人的年龄，出生年份，学生人数等整数相关的状态

(1.2)定义

age=18 

birthday=1990 

student_count=48

（2）浮点型（float）

(2.1)作用

用来记录人的身高，体重，薪资等小数相关的状态

(2.2)定义

height=172.3 

weight=103.5 

salary=15000.89

（3）数字类型的应用

(3.1)数字运算

>>> a = 1 
>>> b = 3 
>>> c = a + b 
>>> c 
4

(3.2)比较大小

>>> x = 10 
>>> y = 11
>>> x > y
False

【2】字符串（str）

（1）作用

用来记录人的名字，家庭住址，性别等描述性质的状态
用来记录描述性信息
- eg：姓名地址邮箱...

（2）定义方式

	方式1：
    	name = 'kevin'
    方式2：
    	name = "kevin"
    方式3：
    	name = '''kevin''' # (当左边有赋值符号和遍历名的时候，它就是字符串)
    方式4：
    	name = """kevin""" # (当左边有赋值符号和遍历名的时候，它就是字符串)

# ps：用引号引起来的部分

对于变量名的值
- 用单引号、双引号、多引号，都可以定义字符串
- 本质上是没有区别的

但是

1、需要考虑引号嵌套的配对问题
```
msg = "My name is Tony , I'm 18 years old!,hope your life : 'wonderful!'" 

msg = 'My name is Tony , I'm 18 years old!,hope your life : "wonderful!"'
```
'''注意：当有引号套用的情况下，外面是单引号里面就要是双引号，外面是双引号里面就要是单引号'''

2、多引号可以写多行字符串

msg = '''         
	天下只有两种人。比如一串葡萄到手，一种人挑最好的先吃，另一种人把最好的留到最后吃。
    照例第一种人应该乐观，因为他每吃一颗都是吃剩的葡萄里最好的；
    第二种人应该悲观，因为他每吃一颗都是吃剩的葡萄里最坏的。 
    不过事实却适得其反，缘故是第二种人还有希望，第一种人只有回忆。 
'''

（3）使用

数字可以进行加减乘除等运算
字符串呢？
- 也可以，但只能进行"相加"和"相乘"运算。

>>> name = 'tony' 
>>> age = '18' 
>>> name + age  #相加其实就是简单的字符串拼接 
'tony18' 
>>> name * 5 #相乘就相当于将字符串相加了5次 
'tonytonytonytonytony'

【3】列表（list）

（1）作用

用来存取多个相同属性的值，并且方便存取
如果我们需要用一个变量记录多个学生的姓名，用数字类型是无法实现，字符串类型则可以记录下来
比如
```
# 字符串类型
stu_names=’张三 李四 王五’
# 列表类型
names_list = ['张三', '李四', '王五']
```
- 存的目的是为了取，此时若想取出第二个学生的姓名实现起来相当麻烦
- 而列表类型就是专门用来记录多个同种属性的值（比如同一个班级多个学生的姓名、同一个人的多个爱好等），并且存取都十分方便

（2）定义

>>> stu_names=['张三','李四','王五']

（3）使用

1、列表类型是用索引来对应值，索引代表的是数据的位置，从0开始计数

详见博客：https://www.cnblogs.com/dream-ze/p/17337354.html

>>> stu_names=['张三','李四','王五'] 
>>> stu_names[0]  
'张三' 
>>> stu_names[1] 
'李四' 
>>> stu_names[2] 
'王五'

2、列表可以嵌套，嵌套取值如下

l = [1, 1.1, 'kevin', [666, 777, 888, 'tony', [22,33, 'kevinNB']]]

# 1. kevinNB在大列表的第几个位置
l1 = l[3]  # [666, 777, 888, 'tony', [22, 33, 'kevinNB']]

# 2. kevinNB在大列表的第几个位置
l2 = l1[4] # [22, 33, 'kevinNB']

# 3. kevinNB在大列表的第几个位置
l3 = l2[2]  # kevinNB
print(l3)
# 整合
l4 = l[3][4][2]
print(l4)

【4】字典（dict）

（1）作用

如果我们需要用一个变量记录多个值，但多个值是不同属性的
- 比如人的姓名、年龄、身高，用列表可以存，但列表是用索引对应值的，而索引不能明确地表示值的含义
- 这就用到字典类型，字典类型是用 key：value 形式来存储数据
  - 其中key可以对value有描述性的功能，能够明确的描述详细信息

（2）定义

定义：大括号括起来，内部可以存放多个元素，元素与元素之间使用逗号隔开，是以K:V键值对的形式存储
- K:
  - 是对V的描述性信息（一般情况是字符串）
- V:
  - 真正的数据，其实相当于变量值,也是任意的数据类型

>>> person_info={'name':'tony','age':18,'height':185.3}

（3）使用

1、字典类型是用key来对应值，key可以对值有描述性的功能，通常为字符串类型
- 字典不能通过索引取值，只能通过字典的K取值
```
>>> person_info={'name':'tony','age':18,'height':185.3} 
>>> person_info['name'] 
'tony' 
>>> person_info['age'] 
18 
>>> person_info['height'] 
185.3 
```

2、字典可以嵌套，嵌套取值如下

info = {
    'username':'tony',
    'addr':{
        '国家':'中国',
        'info':[666, 999, {'编号':466722, 'hobby':['read', 'study', 'music']}]
    }
}

# 1. music在大字典里的位置
d1 = info['addr'] # {'国家': '中国', 'info': [666, 999, {'编号': 466722, 'hobby': ['read', 'study', 'music']}]}

# 2. music在小字典里的位置
d2 = d1['info']  # [666, 999, {'编号': 466722, 'hobby': ['read', 'study', 'music']}]

# 3. music在列表里的位置
d3 = d2[2]  # {'编号': 466722, 'hobby': ['read', 'study', 'music']}

# 4. music在小字典里的位置
d4 = d3['hobby']  # ['read', 'study', 'music']

# 5. music在列表里的位置
d5 = d4[2] # music
print(d5)

# 整合
d6 = info['addr']['info'][2]['hobby'][2]
print(d6)

【5】布尔（bool）

（1）作用

用来记录真假的状态
判断是否正确

（2）定义

只有两种情况
- True
  - 对正确的可行的...
- False
  - 错误不可行的

>>> is_ok = True 
>>> is_ok = False

在python中，什么是真，什么是假?
- 哪些是假的情况：
  - 0,
  - None,
  - '',
  - [],
  - {}...
- 其他都是真

（3）使用

布尔值的命名规范：结果可能是布尔值的情况，我们都采用 is 开头 命名
- is_right
- is_delete
通常用来当作判断的条件，我们将在if判断中用到它
在python中，所有的数据类型都可以转为布尔值

【6】元祖（tuple）

（1）作用

用来存取多个相同属性的值，并且方便存取
如果我们需要用一个变量记录多个学生的姓名，用数字类型是无法实现，字符串类型则可以记录下来
列表可以改变里面的值，但是元祖里面的值不能被改变

（2）定义

小括号括起来，内部可以存放多个元素，元素与元素之间使用逗号隔开，元素不能更改

t1 = (11, 22, 33, 44)

【7】集合（set）

（1）作用

集合（set）是一个无序的不重复元素序列。

（2）定义

可以使用大括号 { } 或者 set() 函数创建集合

注意：创建一个空集合必须用 set() 而不是 { }，因为 { } 是用来创建一个空字典。

大括号括起来，内部可以存放多个元素，元素与元素之间逗号隔开，但是不是K:V键值对的形式
- 创建方式一
```
s = {11,22,33,44}
```
- 创建方式二
```
set(value)
```

集合中的元素不能直接取出

【二】程序与用户交互

【1】程序与用户交互

（1）什么是与用户交互

用户交互就是人往计算机中input/输入数据，计算机print/输出结果

（2）为什么要与用户交互

为了让计算机能够像人一样与用户沟通交流
比如
- 过去我们去银行取钱，用户需要把帐号密码告诉柜员
- 而现在，柜员被ATM机取代
  - ATM机就是一台计算机
  - 所以用户同样需要将帐号密码告诉计算机
  - 于是我们的程序中必须有相应的机制来控制计算机接收用户输入的内容
  - 并且输出结果

（3）如何与用户交互

交互的本质就是输入、输出

(3.1)输入（input）

在python3中input功能会等待用户的输入

用户输入任何内容

input接受的所有数据类型都是 str 类型

# 输入input

password = input('请输入你的密码:>>>')
print(password, type(password)) # input接受的所有数据类型都是str类型
# print(password == '123')   # python中 == 比较的是数据值和数据类型
print(int(password) == 123)  # python中 == 比较的是数据值和数据类型
print(password == str(123))  # python中 == 比较的是数据值和数据类型

然后赋值给等号左边的变量名

>>> username=input('请输入您的用户名：') 
请输入您的用户名：jack # username = "jack"
>>> password=input('请输入您的密码：') 
请输入您的密码：123 # password = "123"

1、在python2中
- 存在一个raw_input功能与python3中的input功能一模一样

2、在python2中

还存在一个input功能

需要用户输入一个明确的数据类型，输入什么类型就存成什么类型

>>> l=input('输入什么类型就存成什么类型: ')
输入什么类型就存成什么类型: [1,2,3]
>>> type(l)
<type 'list'>

(3.2)输出（print）

>>> print('hello world')  # 只输出一个值
hello world
>>> print('first','second','third')  # 一次性输出多个值，值用逗号隔开
first second third

默认print功能有一个 end 参数
- 该参数的默认值为"\n"(代表换行)，可以将end参数的值改成任意其它字符

print("aaaa",end='')
print("bbbb",end='&')
print("cccc",end='@')
#整体输出结果为：aaaabbbb&cccc@

(3.3)输出之格式化输出

[3.3.1] 什么是格式化输出
- 把一段字符串里面的某些内容替换掉之后再输出，就是格式化输出。
[3.3.2] 为什么要格式化输出
- 我们经常会输出具有某种固定格式的内容
  - 比如：'亲爱的xxx你好！你xxx月的话费是xxx，余额是xxx‘
- 我们需要做的就是将xxx替换为具体的内容。

[3.3.3] 如何格式化输出

这就用到了占位符，如：

可以接收任意类型的值

# %s称为占位符（掌握）可以为所有的数据类型占位
res = '亲爱的%s你好！你%s月的话费是%s，余额是%s，我们需要做的就是将xxx替换为具体的内容。'
print(res % ('kevin', 99, 2, 99999999))  # 亲爱的kevin你好！你99月的话费是2，余额是99999999，我们需要做的就是将xxx替换为具体的内容。
print(res % ('kevin1', 991, 2, 100))  # 亲爱的kevin1你好！你991月的话费是2，余额是100，我们需要做的就是将xxx替换为具体的内容。
print(res % ('kevin2', 992, 2, 1199999))  # 亲爱的kevin2你好！你992月的话费是2，余额是1199999，我们需要做的就是将xxx替换为具体的内容。
print(res % ('kevin3', 993, 2, 22999999))  # 亲爱的kevin2你好！你992月的话费是2，余额是1199999，我们需要做的就是将xxx替换为具体的内容。
print(res % ('kevin4', 994, 2, 933999999))  # 亲爱的kevin4你好！你994月的话费是2，余额是933999999，我们需要做的就是将xxx替换为具体的内容。

res1 = 'my name is %s'
print(res1 % 'tony')  # my name is tony

只能接收数字

# %d占位符（了解）只能给数字类型占位
# print("my name is %d" % 'kevin') # TypeError: %d format: a number is required, not str

print("金额：%08d" % 111) # 金额：00000111
print("金额：%08d" % 666666) # 金额：00666666
print("金额：%08d" % 99999999999) # 金额：99999999999

[3.3.4] 练习:接收用户输入，打印成指定格式

name = input('your name: ')
age = input('your age: ') #用户输入18,会存成字符串18,无法传给%d
print('My name is %s,my age is %s' %(name,age))

[3.3.5] 练习:用户输入姓名、年龄、工作、爱好，然后打印成以下格式

------------ info of Tony -----------
Name  : Tony
Age   : 22
Sex   : male
Job   : Teacher 
------------- end -----------------

【三】基本运算符

参考网站（菜鸟教程）：https://www.runoob.com/python/python-operators.html

【1】算数运算符

python支持的算数运算符与数学上计算的符号使用是一致的
- 我们以x=9，y=2为例来依次介绍它们

python中拼接字符串使用 +

s1 = 'hello'
s2 = 'world'
print(s1 + s2)  # helloworld
print(s1 * 10)  # hellohellohellohellohellohellohellohellohellohello

【2】比较运算符

比较运算用来对两个值进行比较，返回的是布尔值True或False
- 我们以x=9，y=2为例来依次介绍它们

【3】赋值运算符

python语法中除了有=号这种简单的赋值运算外
还支持增量赋值、链式赋值、交叉赋值、解压赋值
这些赋值运算符存在的意义都是为了让我们的代码看起来更加精简。
- 我们以x=9，y=2为例先来介绍一下增量赋值

（1）增量运算符

（2）链式赋值

如果我们想把同一个值同时赋值给多个变量名，可以这么做

>>> z=10
>>> y=z
>>> x=y
>>> x,y,z
(10, 10, 10)

链式赋值指的是可以用一行代码搞定这件事

>>> x=y=z=10
>>> x,y,z
(10, 10, 10)

（3）交叉赋值

我们定义两个变量m与n

>>> m=10
>>> n=20

如果我们想将m与n的值交换过来，可以这么做

>>> temp=m
>>> m=n
>>> n=temp
>>> m,n
(20, 10)

交叉赋值指的是一行代码可以搞定这件事

>>> m=10
>>> n=20
>>> m,n=n,m # 交叉赋值
>>> m,n
(20, 10)

（4）解压赋值

如果我们想把列表中的多个值取出来依次赋值给多个变量名
- 可以这么做

>>> nums=[11,22,33,44,55]
>>> 
>>> a=nums[0]
>>> b=nums[1]
>>> c=nums[2]
>>> d=nums[3]
>>> e=nums[4]
>>> a,b,c,d,e
(11, 22, 33, 44, 55)

左右两边的多个值进行赋值时

个数必须一致

names_list = ['kevin', 'tony', 'tank', 'tom']

# ll1, ll2, ll3, ll4 = names_list
# ll1, ll2, ll3, ll4 = ['kevin', 'tony', 'tank', 'tom']

解压赋值指的是一行代码可以搞定这件事

>>> a,b,c,d,e=nums # nums包含多个值，就好比一个压缩包，解压赋值因此得名
>>> a,b,c,d,e
(11, 22, 33, 44, 55)

注意，上述解压赋值，等号左边的变量名个数必须与右面包含值的个数相同,否则会报错

1、变量名少了

>>> a,b=nums
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ValueError: too many values to unpack (expected 2)

2、变量名多了

>>> a,b,c,d,e=nums # nums包含多个值，就好比一个压缩包，解压赋值因此得名
>>> a,b,c,d,e,f=nums
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ValueError: not enough values to unpack (expected 6, got 5)

但如果我们只想取头尾的几个值，可以用*_匹配

>>> a,b,c,d,e=nums # nums包含多个值，就好比一个压缩包，解压赋值因此得名
>>> a,b,*_=nums
>>> a,b
(11, 22)

可以用 * 代替一个集合,将一堆数据取出来

ll1, *a, ll3, ll4 = ['kevin', 'tony', 'tank','a','b', 'tom']

print(ll1, a, ll4) # kevin ['tony', 'tank', 'a'] tom

ps：字符串、字典、元组、集合类型都支持解压赋值

（5）逻辑运算符

逻辑运算符用于连接多个条件
- 进行关联判断
- 会返回布尔值True或False

(5.1)连续多个 `and`

可以用and连接多个条件
- 会按照从左到右的顺序依次判断
- 一旦某一个条件为False
  - 则无需再往右判断
  - 可以立即判定最终结果就为False
- 只有在所有条件的结果都为True的情况下
  - 最终结果才为True。

>>> 2 > 1 and 1 != 1 and True and 3 > 2 # 判断完第二个条件，就立即结束，得的最终结果为False
False

(5.2)连续多个 `or`

可以用or连接多个条件
- 会按照从左到右的顺序依次判断
- 一旦某一个条件为True
  - 则无需再往右判断
  - 可以立即判定最终结果就为True
- 只有在所有条件的结果都为False的情况下
  - 最终结果才为False

>>> 2 > 1 or 1 != 1 or True or 3 > 2 # 判断完第一个条件，就立即结束，得的最终结果为True
True

(5.3)优先级 `not>and>or`

1、三者的优先级关系： not>and>or
- 同一优先级默认从左往右计算。
```
>>> 3>4 and 4>3 or 1==3 and 'x' == 'x' or 3 >3
False
```
2、最好使用括号来区别优先级，其实意义与上面的一样
- (1) not的优先级最高，就是把紧跟其后的那个条件结果取反，所以not与紧跟其后的条件不可分割
- (2) 如果语句中全部是用and连接，或者全部用or连接，那么按照从左到右的顺序依次计算即可
- (3) 如果语句中既有and也有or，那么先用括号把and的左右两个条件给括起来，然后再进行运算
```
>>> (3>4 and 4>3) or (1==3 and 'x' == 'x') or 3 >3
False 
```

3、短路运算：

逻辑运算的结果一旦可以确定
那么就以当前处计算到的值作为最终结果返回

>>> 10 and 0 or '' and 0 or 'abc' or 'egon' == 'dsb' and 333 or 10 > 4
我们用括号来明确一下优先级
>>> (10 and 0) or ('' and 0) or 'abc' or ('egon' == 'dsb' and 333) or 10 > 4
短路：       0      ''            'abc'                    
            假     假              真

返回：                            'abc'

4、短路运算面试题：

>>> 1 or 3
1
>>> 1 and 3
3
>>> 0 and 2 and 1
0
>>> 0 and 2 or 1
1
>>> 0 and 2 or 1 or 4
1
>>> 0 or False and 1
False

（6）成员运算符

注意：虽然下述两种判断可以达到相同的效果，但我们推荐使用第二种格式，因为not in语义更加明确

>>> not 'lili' in ['jack','tom','robin']
True
>>> 'lili' not in ['jack','tom','robin']
True

（7）身份运算符

需要强调的是：
- == 双等号比较的是value是否相等
- is 比较的是id是否相等

id相同，内存地址必定相同，意味着type和value必定相同
value相同type肯定相同，但id可能不同,如下

>>> x='Info Tony:18'
>>> y='Info Tony:18'
>>> id(x),id(y) # x与y的id不同，但是二者的值相同
(4327422640, 4327422256)

>>> x == y # 等号比较的是value
True
>>> type(x),type(y) # 值相同type肯定相同
(<class 'str'>, <class 'str'>)
>>> x is y # is比较的是id，x与y的值相等但id可以不同
False

posted @ 2023-05-16 14:53 Chimengmeng 阅读(115) 评论(0) 编辑收藏举报

刷新页面返回顶部

Dream-Z

Hope Your Life Is Worth It !

基本数据类型与基本运算符

【昨日回顾】

【一】基本数据类型

【1】数字类型

（1）整形（int）

(1.1)作用

(1.2)定义

（2）浮点型（float）

(2.1)作用

(2.2)定义

（3）数字类型的应用

(3.1)数字运算

(3.2)比较大小

【2】字符串（str）

（1）作用

（2）定义方式

（3）使用

【3】列表（list）

（1）作用

（2）定义

（3）使用

【4】字典（dict）

（1）作用

（2）定义

（3）使用

【5】布尔（bool）

（1）作用

（2）定义

（3）使用

【6】元祖（tuple）

（1）作用

（2）定义

【7】集合（set）

（1）作用

（2）定义

【二】程序与用户交互

【1】程序与用户交互

（1）什么是与用户交互

（2）为什么要与用户交互

（3）如何与用户交互

(3.1)输入（input）

(3.2)输出（print）

(3.3)输出之格式化输出

【三】基本运算符

【1】算数运算符

【2】比较运算符

【3】赋值运算符

（1）增量运算符

（2）链式赋值

（3）交叉赋值

（4）解压赋值

（5）逻辑运算符

(5.1)连续多个 and

(5.2)连续多个 or

(5.3)优先级 not>and>or

（6）成员运算符

（7）身份运算符

公告

(5.1)连续多个 `and`

(5.2)连续多个 `or`

(5.3)优先级 `not>and>or`