1.运算符: 数学运算符、比较运算符、逻辑运算符、赋值运算符

数学运算符: +, -, *, /, //, **, %

比较运算符: >, <, ==, !=, >=, <=

逻辑运算符：and, or, not

赋值运算符：=， +=， -=， *=， /=, //=, %=, **=

运算符的优先级: 数学运算符>比较运算符>逻辑运算符>赋值运算符

2.数字类型

整型(int): 0b(二进制)、0o(八进制)、0x(十六进制)

bin()、 oct() hex()

浮点型(float)：支持科学计数法, 19e-2 0.000001 == 1e-6

布尔(bool): True == 1, False == 0

3.字符串(str)

字符串又叫字符集

'', ""

空串: '', ""

空格字符串: ' ', " "

普通字符： 'a', '1', ',', '好'， '', ''

转义字符: \n, \t, ', ", \; 阻止转义： r/R

编码字符: \uXXXX 十六进制数：每一位上的数是0-9或者a-f(A-F)

4.字符的编码

a-z: 97-122

A-Z: 65-90

中文编码范围： 4e00 - 9fa5

chr(编码)

ord(字符)

===========获取字符===========

1.获取单个字符

"""
字符串中的每一个字符都会对应一个唯一的下标(索引)用来表示字符在字符串中的位置。
下标是从0开始一次增加的， 0对应的是第一个字符(0 ~ 字符串长度-1)
可以是从-1开始依次减小,-1代表最后一个字符(-1 ~ -字符串长度)

例如

：'hello'  -> h->(0,-5)  e->(1,-4) l->(2,-3)  l->(3,-2) o->(4,-1)
      '\tpytho\u4e00n'   -> p->(1, -7)

a.语法：
字符串[下标] - 获取字符串中指定下标对应的字符
b.说明:
字符串 - 只要结果是字符串的表达式都可以,例如：字符串字面量, 字符串变量
[] - 固定写法
下标 - 需要获取的字符对应的下标; 注意，这儿的下标不能越界
"""
result = 'how are you!'[0] # 获取字符串'how are you!'中下标是0的字符，并且赋给变量result

print(result)

print('how are you!'[-4])   # y
# print('how are you!'[-13])   # IndexError: string index out of range

str1 = 'good good study! day day up!'
print(str1[10])

2.获取部分字符(字符串切片)

"""
方法一：
a.语法：
字符串[开始下标:结束下标:步长] - 从开始下标开始，获取到结束下标前为止。每次下标值加上步长去获取下一个
b.说明：
字符串 - 只要结果是字符串的表达式都可以,例如：字符串字面量, 字符串变量
[] - 固定写法
开始下标、结束下标 - 下标值（这儿的下标可以越界）
步长 - 必须是整数(正数和负数都行)；如果步长是正数，是从开始下标开始从前往后获取；
如果步长是负数，是从开始下标开始从后往前获取；

c.注意：
当步长为正，要求开始下标对应的字符的位置必须在结束下标对应的字符的位置的前面,否则结果是空串！
当步长为负，要求开始下标对应的字符的位置必须在结束下标对应的字符的位置的后面，否则结果是空串!

不管怎么取，结束下标一定取不到！
"""

str1 = 'hello python!'
print('结果1：', str1[0:-1:2])   # 从前往后取
print('结果2：', str1[-1:0:-2])    # 从后往前取

print('结果3：', str1[-1:-100:-1])   # 结束下标越界
print('结果4：', str1[100: -100: -1])  # 下标越界

练习：获取一个字符串中所有下标是奇数的字符（顺序）

print(str1[1:100:2])

str2 = "{'name':'小明', 'age': 18}"
print(str2[1:-1:1])

"""
方法二：(省略步长)
字符串[开始下标:结束下标] - 步长是1；从开始下标开始到结束下标前为止，一个一个的取！
"""
print('when i was young!'[2:6])

"""
方法三:(省略开始下标和结束下标)
a.省略开始下标
字符串[:结束下标:步长] - 当步长是正数,从字符串的第一个字符开始取到结束下标前为止;
当步长是负数，从字符串的最后一个字符开始取到结束下标前为止.
b.省略结束下标
字符串[开始下标::步长] - 当步长是正数,从开始下标开始取到字符串最后一个字符为止;
当步长是负数，从开始下标开始取到字符串的第一个字符为止
"""

str3 = 'when i was young!'
print(str3[:6], str3[:6:-1])
print(str3[2:], str3[2::-1])
print(str3[:])
print(str3[::-1])    # 让字符串倒序
print(str3)

1.字符串支持的运算符： +, *, >, <, ==, != ,>=, <=

python中的字符串支持数学运算符中的+和*,以及所有的比较运算符

"""
a. + : 字符串1 + 字符串2 - 将字符串1和字符串2拼接在一起产生一个新的字符串
注意：字符串和数字不能混合相加!
b. * ：字符串 * N - N是正整数; 字符串重复N次产生一个新的字符串
"""

new_str = 'abc' + '123'
print(new_str)

name = '张三'
message = '吃饭了吗？'
print(name+message+'....')

# print('abc'+123)   # TypeError: must be str, not int

new_str = 'abc'*3
print(new_str)

print(('abc'+'123')*2)    # abc123abc123
print('abc'+'123'*2)      # abc123123

"""
c.比较是否相等
==, != 可以判断两个字符串是否相等或者不相等

d.字符比较大小：从第一个字符开始依次往后找，找到第一个不相等的字符对，判断它们的编码值的大小，
谁的编码值大，对应的字符串就大；不会再往后比较了！

应用：
1.判断是否是小写字母: 'a'<=char<='z' <===> char>='a' and char<='z'
2.判断是否是大写字母: 'A'<=char<='Z'
3.判断是否是字母: 'a' <= char <= 'z' or 'A' <= char <= 'Z'
"""

print('abc' == 'abc')    # True
print('abc' == 'cba')    # False
print('abc' != 'abc')    # False

print('abdcb' > 'abczde')

判断一个字符串中第3个字符是否是字母

str1 = 'sh是23.ssy23'
char = str1[2]     # 将第3个字符取出
print('是否是字母:', 'a' <= char <= 'z' or 'A' <= char <= 'Z')
print('是否是中文:', '\u4e00' <= char <= '\u9fa5')

2. in和not in操作

"""
字符串1（是否在）字符串2中
字符串1 in 字符串2 -> 判断字符串2中是否包含字符串1(判断字符串1是否是字符串2的子串)判断字符串1（是否在）字符串2中
字符串1 not in 字符串2 -> 判断字符串2中是否不包含字符串1(判断字符串1是否是字符串2的子串)
"""

print('abc' in 'hello abc')     # True
print('abc' in 'ahello bc')     # False

print('abc' not in 'hello abc')     # False
print('abc' not in 'ahello bc')     # True
print('A' in 'hello Abc')

3. len函数

"""
len(序列) - 获取序列长度, 获取序列中元素的个数
len(字符串) - 获取字符串的长度（字符的个数） -- 结果是一个整数

注意：
一个可以转移的转义字符的长度是1！
一个编码字符的长度是1！
一个空格字符的长度是1！
手动在键盘上按一个tab，一般是4个空格，长度是4; 一个\t来表示的tab，长度是1
"""

print(len('abc'))

str1 = input('请输入:')
last_char = str1[len(str1)-1] # 获取输入的字符串中的最后一个字符
print(last_char)

str1 = ' abc'
str2 = '\tabc'
print(str1)
print(str2)
print(len(str1), len(str2)) # 手动输入的tab和\t对应的字符个数可能不一样！\t永远是1

===========格式字符串============

"""
1.什么是格式字符串：
在字符串中通过格式占位符来代替字符串中变化的部分，然后在后面通过数据或者变量确定变化

语法：
包含占位符的字符串 % (值1, 值2, 值3...)
说明：
占位符 - %s 字符串
%d 整数
%f 小数 (%.Nf 保留小数点后N位小数)
%c 字符 (可以将数字转换成字符)
% - 固定写法
() - 固定写法，字符串中只有一个占位符的时候，这个()可以省略
括号中的值 - 值和占位符要一一对应(个数、类型、位置都要对应)
"""
name = input('姓名:')
age = 18
sex = '男'

加操作

mesage = '我叫XXX，今天xx岁,性别:X, 月薪x万'

mesage = '我叫'+name+',今年'+age+'岁，性别:'+sex

print(mesage)

格式字符串

message = '我叫%s,今年%s,性别:%d, 月薪%.2f万字符:%c' % (name, age, sex, 1.5, 97)
print(message)

练习: 输入一个字符串, 用一个变量保存输入的字符串的相关信息：XXX的长度是XX,最后一个字符是X

例如: 输入abc -> abc的长度是3,最后一个字符是c

input_str = input('输入一个字符串:')
message = '%s的长度是%d, 最后一个字符是%c' % (input_str, len(input_str), input_str[-1])
print(message)

print('%s-%d-%c' % ('abc', 100, 'A'))

"""
==========类型转换==========
1.基本语法
语法:
类型名(数据) - 将指定数据转换成指定类型

说明：
类型名 - 任何python支持的，或者自定的类型都可以
数据 - 需要转换的对象(类型不同要求可能不一样)

2.转换实例
int(数据) -> 将其他数据转换成整型
float(数据) -> 将其他数据转换成浮点型
bool(数据) -> 将其他类型转换成布尔
str(数据) -> 将其他数据转换成字符串
"""

age = input('年龄:')

print(type(age), age)

print('是否能进入网吧：', int(age) >= 18)

1.转换成整型

a = int(-10.90) # 所有浮点数可以转换成整数，直接保留整数部分
b = int(False) # 所有布尔可以转化成整数， True -> 1; False -> 0
c = int('-120') # 只有去掉字符串的引号后本身就是一个整数的字符串才能转换成整型
print(a, b, c)

2.转换成浮点型

a = float(100) # 所有整数都可以转换成浮点数，在后面加.0
b = float(True) # 所有布尔可以转化成浮点数， True -> 1.0; False -> 0.0
c = float('12.9') # 去掉引号后本身就是一个数字的字符串能转换成浮点型
print(a, b, c)

3.转换成布尔类型

python中所有的数据都可以转换成布尔

所有为空为0的值都会转换成False,其他都是True

a = bool(0)
b = bool(-0.0)
c = bool('')
d = bool([])
e = bool({})
f = bool(None)
print(a, b, c, d, e, f)

4.转换成字符串类型

python中所有的数据都可以转换成字符串,而且转换的时候就是单纯的在最外面加引号

a = str(100)
print(a)
print('abc'+str(100))

练习：输入三个数字，求三个数的和

num1 = input('第一个数:')
num2 = input('第二个数:')
num3 = input('第三个数:')
print(float(num1)+float(num2)+float(num3))

inputstr = input('输入三个数以逗号隔开：')

print(inputstr)

表中所有字符串相关方法的使用方式都是：字符串.方法名()

1.capitalize()

字符串.capitalize() - 将指定的字符串的第一个字符转换成大写字母,返回新的字符串

注意：只有第一个字符是字母的时候才有效

str1 = 'abc'
print(str1.capitalize())

2.字符串对齐方式

"""
字符串.center(width, fillchar) - 居中, width决定新的字符串的长度, fillchar就是用来填充多出来的位置的字符
width是整数，fillchar是字符
字符串.ljust(width, fillchar) - 左对齐
字符串.rjust(width, fillchar) - 右对齐
"""
str1 = 'abc'
print(str1.center(7, '0'))
print(str1.ljust(7, '*'))
print(str1.rjust(7, '='))

3.count

字符串1.count(字符串2) - 在字符串1中统计字符串2出现的次数

print('abc and hight a'.count('abc'))

4.isalpha

字符串.isalpha() - 判断字符串中是否全是字母

注意：非ASCII码表中的字符检测不出来！

print('aSH'.isalpha())

5.join

字符串1.join(字符串2) - 将字符串1插入到字符串2中的每个字符之间

new_str = '**'.join('abc')
print(new_str)

6.split

字符串1.split(字符串2) - 以字符串2去切割字符串1,返回一个列表

day 4