基本数据类型

• 变量的值的类型，也就是可以为变量赋哪些值

  整数和小数

• 整数 **: **所有整数 例如 : a = 1 b = 100 c =999 都是int类型

• 小数常量 : 所有小数 例如 a = 1.2 b=6.66 用float类型表示
• 例外(二进制换算导致):

  0.1+0.2 0.30000000000000004

  数字分隔

  print(123456789) print(123_456_789)
  123456789 123456789

布尔值和空值

• 布尔: 只有2个值一个是True 一个是False
• None常量：只有一个数值就是None 也就是空值

  print(type(3), type(1.3), type(True), type(None)) **

• 布尔: 只有2个值一个是True 一个是False

• None常量：只有一个数值就是None 也就是空值

  字符串

• 字符串是由数字、字母、下划线组成的一串字符，用单引号或双引号包括

  a = ‘hello’

• 注意

  • 单引号或双引号不能混合使用

    转义字符

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

• 总结
• \t 表示制表符
• \n 表示换行符
• \ 表示反斜杠
• \’ 表示 ‘
• \’’ 表示 ‘’
• r”” 引号内所有字符全部成为原字符，不具备其他字符的功能

  print(‘hel\tlo’)print(‘hel\nlo’)print(‘hel\lo’)print(‘hel\’lo’)print(r”‘hel\lo’”)

  hel lo hel lo hel\lo hel’lo
  ‘hel\lo’

长字符串

• 长字符串 又叫做文档字符串 我们使用三重引号来表示一个长字符串’’’ ‘’’
• 三重引号可以换行，并且会保留字符串中的格式
• 三重引号的作用: 注释，保留格式

例如:

a = ‘千江有水千江月，’ \ ‘万里无月万里天。’
b = “””
千江有水千江月，
万里无月万里天。
“””
print(a)
print(b)

千江有水千江月，万里无月万里天。

千江有水千江月，    
万里无月万里天。

格式化字符串

• 第一种格式化字符串 拼串
  

• 第二种格式化字符串 参数传递

  x = ‘Hello’
  y = ‘-World!’
  print(x+y)
  print(‘x+y=’, x+y)

  Hello-World! x+y= Hello-World!

• 第三种格式化字符串 占位符

  • %s 字符串占位
  • %f 浮点数占位
  • %d 整数占位

    import math s1 = ‘I love %s’ % ‘you!’
    s2 = 345667s3 = math.pi print(‘s1=’, s1)
    print(‘s21=%10d’ % s2)
    print(‘s22=%s’ % s2)
    print(‘s31=%f’ % s3)
    print(‘s32=%20f’ % s3)
    print(‘s33=%50s’ % s3)

    s1= I love you! s21= 345667 s22=345667 s31=3.141593 s32= 3.141593 s33= 3.141592653589793

• 第四种格式化字符串 f’{变量}’

  x = ‘Python’
  y = ‘Java’
  str1 = f’我喜欢 {x} 和 {y}.’
  print(str1)

我喜欢 Python 和 Java.

• str.format ()

  x = ‘Python’
  y = ‘Java’
  str2 = ‘我喜欢 {} 和 {}.’.format(x, y)
  print(str2)

我喜欢 Python 和 Java.

字符串的其他操作

• len() 字符串的长度

  str3 = ‘abcdefghijklmnopqrstuvwxyz’
  str4 = “你好吗”
  print(‘Length of str3 is’, len(str3))
  print(‘Length of str4 is’, len(str4))

  Length of str3 is 26 # 字符个数 Length of str4 is 3 # 汉字个数

#经常与range()联合使用
s = "I love you!"
for i in range(len(s)):
    print(s[i])
I
l
o
v
e
y
o
u
!

• max() 最大值 # 通过ascii表格来比对的
• min() 最小值

  str3 = ‘abcdefghijklmnopqrstuvwxyz’ str4 = “你好吗” print(‘max(str3)=’, max(str3))
  print(‘max(str4)=’, max(str4))
  print(‘min(str3)=’, min(str3))
  print(‘min(str4)=’, min(str4)) ** max(str3)= z # 字母顺序最后 max(str4)= 好 # 汉字笔画最多 min(str3)= a # 字母顺序最先 min(str4)= 你 # 汉字笔画最少

• ord()查找ASCII码的函数 ``` print(‘a=’, ord(‘a’)) print(‘A=’, ord(‘A’)) print(‘Z=’, ord(‘z’)) print(‘z=’, ord(‘Z’)) print(‘0=’, ord(‘0’)) print(‘9=’, ord(‘9’)) print(‘=’, ord(‘‘)) print(‘ =’, ord(‘ ‘))

a= 97 A= 65 Z= 122 z= 90 0= 48 9= 57 *= 42 = 32

- split()分割字符串, 分割出来的结果使用列表来装的  默认用空格来分割
> str3 = 'abcdef,ghijklmno,pqrstuvwxyz'<br />print(str3.split(','))  # 逗号作为分隔符<br />print(str3.split(',', 1)) # 逗号作为分隔符，划分为x+1部分
> **
> ['abcdef', 'ghijklmno', 'pqrstuvwxyz']
> ['abcdef', 'ghijklmno,pqrstuvwxyz']
- join()拼接字符串, ''是拼接的规则
```python
a = 'i love you'
b = a.split(' ')
c = '*'.join(b)
print(a)
print(b)
print(c)
i love you
['i', 'love', 'you']
i*love*you

• find()查找字符串 ```python a = ‘i love you’ print(a.find(‘you’)) print(a.find(‘a’)) print(a.index(‘you’)) print(a.index(‘a’))

7 -1 7 ValueError: substring not found

- replace() 替换字符串, 2个参数，第一个是需要被替换的内容，第二个是替换的结构的数据
```python
a = 'i love you'
b = a.replace('you', 'her')
print(a)
print(b)
i love you
i love her
-----
a = 'abcdefg'
print(a[0])
#a[0] = 'x' # 报错
b = a.replace('a', 'x')
print(b)
a
xbcdefg

• partition() 把字符串按照规则分割为三部分 ```python a = ‘i love you and her’ print(a.partition(‘love’)) print(a.partition(‘i’)) print(a.partition(‘x’))

(‘i ‘, ‘love’, ‘ you and her’) (‘’, ‘i’, ‘ love you and her’) (‘i love you and her’, ‘’, ‘’)

- 去空格
   - s.strip() 左右两边去空格
   - s.lstrip() 去左边空格
   - s.rstrip() 去右边空格
```python
a = ' I love you  !  '
print(a)
print(a.strip())
print(a.lstrip())
print(a.rstrip())
 I love you  !  
I love you  !
I love you  !  
 I love you  !

• 字符串大小写
  • s.upper() 全部大写
  • s.lower() 全部小写
  • s.isupper() 判断是不是大写
  • s.islower() 判断是不是小写 ```python a = ‘I love you!’ b = a.upper() print(a) print(b) print(a.isupper()) print(a.islower()) print(b.isupper()) print(b.islower())

I love you! I LOVE YOU! False False True False

- 字符串大小写切片
```python
# 索引  相当于教室分配的作为号， 从左数是从0开始，从右数是从-1开始
#   a   b   c   d   e   f   g   h   i
#   0   1   2   3   4   5   6   7   8
#   -9  -8  -7  -6  -5  -4  -3  -2  -1
# 切片  ：在内存当中，数据是连续存储的数据类型，就可以切片
# 语法： 变量[起始位置：结束为止：步长] 左闭右开区间  步长默认是1
# [::]  起始位置默认从0开始，结束为止默认取到最后所有的数
a = 'abcdefghi'
print(a[2:4:2])
print(a[::])
c
abcdefghi
# 逆序打印
print(a[::-1])
print(a[-1::-1])
ihgfedcba
ihgfedcba
print(a[-1:-5:-1])
print(a[-5:-1:1])
print(a[-2:-6:-1])
ihgf
efgh
hgfe

运算符

运算符的概念

• 运算符用于执行程序代码运算，会针对一个以上操作数项目来进行运算。例如：2+3，其操作数是2和3，而运算符则是“+”

  运算符的分类

• 算术运算符

• 赋值运算符
• 比较运算符（关系运算符）
• 逻辑运算符

• 条件运算符（三元运算符）

  算术运算符

• 加法运算符 表现形式 +

• 减法运算符 表现形式 -
• 乘法运算符 表现形式 *
• 除法运算符 表现形式 /
• // 整除，只会保留计算后的整数位，总会返回一个整型
• % 取模，求两个数相除的余数
• ** 幂运算，求一个值的几次幂 ```python

  加减乘除 整除 取余 幂函数

  a = 1 + 2 print(a)

3

b = ‘python’ + ‘pycharm’

print(b)

pythonpycharm

a = 1 * 2.0 print(a)

2.0

b = 2 / 1 print(b)

2.0

b = ‘python’ * ‘pycharm’ print(b)

TypeError: can’t multiply sequence by non-int of type ‘str’

a = ‘python’ * 2 print(a)

pythonpython

b = ‘python’ - ‘p’ print(b)

TypeError: unsupported operand type(s) for -: ‘str’ and ‘str’

整除

a = 9 // 2 print(a)

4

取余

a1 = 9 % 2 a2 = -10 % 3 print(‘a1=’, a1) print(‘a2=’, a2)

a1= 1 a2= 2

幂运算

a = 3 ** 2 print(a)

9

开平方

a = 9 ** 0.5 print(a)

3

开3次方

a = 64 ** (1/3) print(a)

3.9999999999999996

赋值运算符

x = 1 x = x + 3 print(x)

4

a = 1 a = 2 print(a)

2

True 可以看做是1，False可以看做是0

比较运算符 得出来的结果是一个布尔值 True和False

result1 = ‘2’ > ‘1’ result2 = ‘2’ > ‘11’ # 比较的ASCII序号 result3 = ‘hello’ == ‘hello’ result4 = ‘hello’ is ‘hello’ result5 = 1 == True result6 = 1 is True # 比较的是id print(‘result1=’, result1) print(‘result2=’, result2) print(‘result3=’, result3) print(‘result4=’, result4) print(‘result5=’, result5) print(‘result6=’, result6)

result1= True result2= True result3= True result4= True result5= True result6= False

<a name="04wtE"></a>
## 赋值运算符
赋值运算符的特殊写法  x = x + 3 其实是和 x += 3 是一样的
-  +=  （x+= 3 相当于 x = x + 3 ）
-  -= （x -= 3 相当于 x= x - 3 ） 
- *=  （x *= 3 相当于 x = x* 3 ）
- **= （x **= 3 相当于 x = x ** 3 ）
- /=  （x /= 3 相当于 x = x/ 3 ）
- //= （x //= 3 相当于 x = x // 3 ）
- %=  （x %= 3 相当于 x= x % 3 ）
<a name="9SPFG"></a>
## 比较运算符
- 比较运算符用来比较两个值之间的关系，总会返回一个布尔值.如果关系成立，返回True，否则返回False
- > 比较左侧值是否大于右侧值
- >= 比较左侧的值是否大于或等于右侧的值
- < 比较左侧值是否小于右侧值
- <= 比较左侧的值是否小于或等于右侧的值
- 特殊的比较方式
   - == 比较两个对象的值是否相等
   - != 比较两个对象的值是否不相等
   - is 比较两个对象是否是同一个对象，比较的是对象的id
   - is not 比较两个对象是否不是同一个对象，比较的是对象的id
<a name="kVwTP"></a>
## 逻辑运算符
<a name="glUAw"></a>
### not 逻辑非
- not可以对符号右侧的值进行非运算，对于布尔值，非运算会对其进行取反操作，True变False，False变True
```python
# 逻辑非 not
# 0 空串‘’ None 还有一些表示空性的值会转换为False，其余剩下的所有的值都是True
a = 1
a = not a
print(a)
False
a = None
a = not a
print(a)
True
a = 0
a = not a
prit(a)
True
a = ''
a = not a
print(a)
True
a = []
a = not a
print(a)
True

and 逻辑与

• and可以对符号两侧的值进行与运算。 只有在符号两侧的值都为True时，才会返回True，只要有一个False就返回False
• 与运算是找False的，如果第一个值为False，则不再看第二个值 ```python

  逻辑与 and

  0 空串‘’ None 还有一些表示空性的值会转换为False，其余剩下的所有的值都是True

  result1 = True and True result2 = True and False result3 = False and False print(‘result1=’, result1) print(‘result2=’, result2) print(‘result3=’, result3)

result1= True result2= False result3= False

<a name="LmieF"></a>
### or 逻辑或
- 或运算两个值中只要有一个True，就会返回True
- 或运算是找True的
```python
result1 = False or True
result2 = True or True
result3 = False or False
print('result1=', result1)
print('result2=', result2)
print('result3=', result3)
result1= True
result2= True
result3= False

非布尔值的与或运算

• 当我们对非布尔值进行与或运算时，Python会将其当做布尔值运算，最终会返回原值
• 非布尔值与运算的规则
  • 与运算是找False的，如果第一个值是False，则不看第二个值。如果第一个值是False，则直接返回第一个值，否则返回第二个值
• 非布尔值或运算的规则
  • 或运算是找True的，如果第一个值是True，则不看第二个值。如果第一个值是True，则直接返回第一个值，否则返回第二个值 ```python

    非布尔值的与或计算

    and计算: 他是找False， 如果第一个值是False，则不看第二个值，直接返回第一个值，如果第一个值是True，则不看第二个值，直接返回第二个值

    result1 = 1 and 2 result2 = 0 and 2 result3 = None and 0 result4 = 1 and 0 print(‘result1=’,result1) print(‘result2=’,result2) print(‘result3=’,result3) print(‘result4=’,result4)

result1= 2 result2= 0 result3= None result4= 0

or 运算: 它是找True， 如果第一个值是True，则不看第二个值，直接返回第一个值，如果第一个值是False，直接返回第二个值

result1 = 1 or 0 result2 = 1 or 2 result3 = 0 or 2 result4 = 0 or None print(‘result1=’, result1) print(‘result2=’, result2) print(‘result3=’, result3) print(‘result4=’, result4)

result1= 1 result2= 1 result3= 2 result4= None

<a name="ouHgO"></a>
## 条件运算符（三元运算符） 
![QQ截图20200916153536.png](https://cdn.nlark.com/yuque/0/2020/png/1759152/1600241754495-f6a151ef-c017-4b5f-978b-b39995e34c82.png#align=left&display=inline&height=357&margin=%5Bobject%20Object%5D&name=QQ%E6%88%AA%E5%9B%BE20200916153536.png&originHeight=357&originWidth=683&size=10731&status=done&style=none&width=683)
条件运算符在执行时，会先对条件表达式进行求值判断<br />如果判断结果为True，则执行语句1，并返回执行结果<br />如果判断结果为False，则执行语句2，并返回执行结果<br />语法： 语句1 if 条件表达式 else 语句2
```python
# 条件运算符： if后面的判断为True则返回if前面的，否则返回else后面的
a = input('input a:')
b = input('input b:')
print('b 的值比较大') if a < b else print('a 的值比较大')
input a:6
input b:2
a 的值比较大
input a:6
input b:8
b 的值比较大
# i = 1
# if i < 5:
#     pass

运算符的优先级

运算符优先级参照表

a = 2 + 3 * 4
print(a)
14
b = 2 or 3 and 4
# and的优先级要高与or， 2
print(b)
2
b = (2 or 3) and 4
print(b)
4

作业

• 以4种格式化字符串的方式来实现 521 xxx 嫁给我好吗？ ```python girl = ‘江疏影’

拼串

str1 = [‘521 ‘, ‘ 嫁给我好吗？’] print(girl.join(str1))

replace

str2 = ‘521 xxx 嫁给我好吗？’ print(str2.replace(‘xxx’, girl))

%s

print(‘521 %s 嫁给我好吗？’ % girl)

f’’

print(f’521 {girl} 嫁给我好吗？’)

format

print(‘521 {} 嫁给我好吗？’.format(girl))

- 现在有a b c三个变量，三个变量中分别保存有三个数值，请通过条件运算符获取三个值中的最大值
```python
a = input('please input 1st numbers:')
b = input('please input 2nd numbers:')
c = input('please input 3rd numbers:')
#方法一：
r = a if a > b else b
s = r if r > c else c
print(s)
# 方法二
r = a if a > b and a > c else b if b > c else c
print(r)
# 方法三：
r = (a if a > b else b) if (a if a > b else b) > c else c
print(r)