1.python基础

1.1.标识符（专门用来命名的-变量、函数、类）

'''
1）要求
a.是由字母数字下划线组成（只能少不能多）
b.数字不能开头的
c.大小写敏感的(大写和小写不一样，例如：abc和Abc、ABC不一样)
d.python3以后，标识中可以包含非ASCII码(可以包含中文),但是在实际开发中不建议使用

 A.B.C  A-大版本，重大修改

1.2.关键字：

'''
'False', 'None', 'True', 'and',
'as', 'assert', 'break', 'class', 'continue',
'def', 'del', 'elif', 'else', 'except', 'finally', 
'for', 'from', 'global', 'if', 'import', 'in', 'is', 'lambda', 
'nonlocal', 'not', 'or', 'pass', 'raise', 'return', 'try', 'while',
 'with', 'yield'
'''

1.3.行与缩进

'''
缩进的要求：
'''
a.同一级的代码必须保持同一缩进。(统一使用tab来产生缩进)
b.通过缩进来产生代码块（类似于其他语言中的{}）
'''
行的规范
'''
a.声明函数的前后必须有两个换行
b.声明类的前后也需要两个换行
c.多个功能模块间用换行隔开
'''
 5. 多行显示（一句代码多行显示）
a.在需要换行的地方加\,然后在后面换行。换行后缩进不受限制
'''

1.4.python中的基本数据类型

'''
a.数字相关的
int(整型)，float(浮点型)，complex(复数)
b.bool(布尔)
只有True和False两个值
c.str(字符串)
d.list(列表)
e.dict(字典)
f.tuple(元祖)
g.set(集合)
h.function(函数)
i.bytes(字节)
'''

2.变量

2.1.定义

'''
声明变量就是在内存中开辟空间存储数据。（变量就是用来存储数据的）
# python是动态语言

2.2.结构

'''
1.怎么声明变量
格式: 变量名 = 值
说明：
a.类型:python声明变量的时候不需要确定类型
b.变量名:标识符，不能是关键字；见名知义，PEP8命名规范(所有的字母都小写，多个单词之间用_隔开)
=：赋值符号，将右边的值赋给左边的变量
值：表达式(就是有结果的，例如：字面量，运算表达式(10+20),其他的变量)
"""
c.声明了一个变量name，赋值为'路飞'。使用name的时候，就相当于在使用'路飞'
name = '路飞'
print(name)


d.python中每条语句结束可以不用分号。但是如果一行要写多条语句，就必须加分号
number1 = 10; number2 = 100

e.2.同时声明两个变量，并且赋一样的值
str1 = str2 = str3 = 'abc'

f.使用print同时打印多个值
print(str1, str2, str3) 

g.id函数
# id(变量) --- 查看变量的地址
# python声明变量，和给变量赋值的原理: 先在内存中开辟空间存数据，然后再将变量名作为数据对应的内存的标签
a = 10
print(id(a))
a = 100
print(id(a))
'''

2.2.数字和布尔

'''
# 1.int(整型)
# 所有的整数都是整型,python3中的整型只有int,python2中有int和long
num1 = 10
num2 = - 100

# 内置函数：type() -- 获取括号中数据的类型
print(type(num1), type(num2))

# 2.float(浮点型)
# 所有带小数点的数，都是浮点型。python中的浮点型只有float
num5 = 2e2
num6 = -3.14

# 3.bool(布尔)
# 布尔就True和False
# True - 1; False - 0
bool1 = True 
bool2 = False
print(type(bool2))

'''

2.3.运算符

'''
# 1.数学运算符:+(加), -(减), *(乘), /(除), //(整除), %(取余), **(幂运算)
# a.+,-,*,/,%和数学中的加、减、乘、除、求余的功能一模一样
print(10+12.9)
print(100 - 20)
print(2*3.5)
print(5/2)
print(3%2)  

# b.//(整除)
# 求商，商只取整数部分
print(6.3//2)  

# c.**(幂运算)
# x**y -- x的y次方 
print(2**3)
print(9**0.5)  

# 2.比较运算: >(大于), <(小于), ==(等于), !=(不等于), >=(大于等于), <=(小于等于)
# 所有的比较运算的结果都是布尔值
print(10 > 20)
print(10 != 20)
print(20 >= 20)

# 3.逻辑运算符: and(与)，or(或), not(非)
# 逻辑运算符操作的数据是布尔值，返回的结果也是布尔
# and(与) -- 和、并且
# 两个都是True结果才是True，只要有一个是False结果就是False
print(True and True)   # True
print(True and False)  # False
print(False and True)  # False
print(False and False) # False
# 什么时候使用：要求两个或者多个条件同时满足

# or(或) -- 或者
# 只要有一个是True结果就是True。两个都是False结果才是False
# 什么时候使用:要求两个或者多个条件只要一个条件满足就行  

# not(非)
# Ture变成False, False就变成True

# 4.赋值运算符：=(赋值)，+=， -=， *=， /=, %=, //=, **=
# 赋值符号的左边必须是变量；运算顺序是，先算赋值符号右边的值，然后再将右边的结果赋给左边
# a. 变量 = 值
# b. 变量 += 值 
# 这儿的变量必须是已经声明过的变量
# c.变量 = 变量 (运算符) 值 （a *=b---->a = a * b）



# 5.运算符的优先级
# 正负 > 数学运算符 > 比较运算符 > 逻辑运算符 > 赋值运算符
# 数学运算符中: ** > (*,/,%,//) > (+,-)
# 优先级高的先计算，如果优先级相同就从左往右依次计算。可以通过加括号，改变运算顺序
# 补充: 变量必须先声明，再使用。
'''

2.4.进制

'''
a.进制的表示
二进制：0b101010
八进制：0o23213
十六进制:0x1AB

b.进制之间的转化
转换成二进制：bin(x)
转换成八进制：oct(x)
转换成十进制：int('x',y) ----->x:为需要转换的数（注意加引号），y--->转化的数最初是多少进制
转换成十六进制：hex(x)

c.原码：数据的二进制形式
正数的原码：符号位的值是0，后面是数值大小
负数的原码：符号位的值是1，后面是去掉符号的数值大小

d.反码：
正数的反码：反码和原码一样
负数的反码：符号不变，后面的每一位的值取反(0->1, 1->0)

e.补码：
正数的补码：补码和原码一样
负数的补码：反码+1

3.字符串

3.1.定义：

'''
a.用单引号或者双引号括起来的字符集就是字符串
'ahshu123~!*&&^耍数组', "a k987"
b.字符串中的每个独立的单元我们叫字符，
  例如:字符串'abc123'中'a','b','c','1','2','3'就是字符
'''

3.2.转义字符

'''
说明：python中没有字符类型，如果要表示字符，就是用一个长度是1的字符串表示,例如：'a','1',
长度：指的就是字符串中字符的个数，例如:'abc' - 长度是3 ，'abc123, 你好'-长度是:10


a.通过\将一些特殊的字符转换成一个具有特殊功能或者特殊意义的字符，就是转义字符。

b.常见的转义字符：
\n --- 换行
\t --- 制表符(相当于tab键)
\\ --- \
\' --- '
\" --- "
在计算字符串长度的时候，转义字符的长度是1
'''

3.3.字符编码

'''
# 3.Unicode编码
"""
a.python中字符的编码采用的是Unicode编码
b.Unicode是采用两个字节对一个字符进行编码(2^15),能够将世界上所有的符号进行编码
c.Unicode编码中包含了ascii码

将字符转换成指定的数值，这个过程就是编码。（编码的目的是方便计算机存储）
将数值转换成对应的符号的过程就是反编码(解码)

0 --> 0
'0' --> 48
"""
# 1).将Unicode码转换成字符: chr(解码)
print(chr(0xA001))
print(chr(0xAC00))
print(chr(0x4e60))

# 2).将字符转换成Unicode编码: ord(编码)
code1 = ord('余')  # 结果是10进制的
code2 = ord('婷')
print(hex(code1), hex(code2))

'''

3.4.获取字符

'''
# 字符串实质可以是一个不可变的序列，序列内容是字符。
# 一旦字符串确定，那么里面的字符和字符的位置就不可变了，例如:'abc'
# 1.怎么获取单个字符
'''
python中的字符串，可以通过下标(索引)来获取指定位置上的字符：字符串[索引]
说明：
    a.字符串：可以是字符串值，也可以是字符串变量
    b.[]: 中括号使固定语法
    c.索引：从0开始到字符串长度减1 （0对应第一个字符）； 
           -1 ~ -长度（-1对应的是最后一个字符, -2对应的是倒数第2个字符）

注意：索引不能越界，否则会报错(产生异常)
'''
2. 获取部分字符(获取子串) -- 切片
# 字符串[下标1:下标2] ： 从下标1开始，获取到下标2前的所有的字符
# （从下标1开始，每次下标值加1，一直加到下标2前）
# 注意：下标1对应的位置，一定要在下标2对应的位置前
str2 = 'hello world'

print(str2[0:4])  # hell
print(str2[2:7])  # llo w
print(str2[2:-1]) # llo worl
print(str2[3:12]) # 切片时下标可以越界，越界的时候就取临界值
'''

字符串[下标1:下标2:步进]
"""
从下标1开始获取，每次下标值增加步进值，没增加一次取一个字符，直到取到下标2前为止
注意：a.步进如果是正数，那么下标1对应的字符的位置一定要下标2对应的位置的前面；
     步进是负数，那么下标1对应的位置一定要在下标2对应的位置的后面
     b.下标2对应字符是取不到的
"""
str3 = 'helloPython'
print(str3[0:5:2])  # hlo   步进:3  hl  
print(str3[-1:5:-1]) # nohty

下标的省略
"""
切片的时候，下标1和下标2是可以省略的

下标1省略：默认从开头开始获取(开头可能是字符串的第一个字符，也可能是字符串的最后一个字符)


下标2省略: 从下标1位置开始获取，获取到结束(结束可能是字符串的最后一个字符，也可能是字符串的第一个字符)

3.5.字符串的相关运算

1. + 运算符
"""
字符串1+字符串2:
python支持两个字符串相加, 其效果就是将两个字符串拼接在一起产生一个新的字符串

注意：如果+的一边是字符串，那么另外一个也必须是字符串
"""
print(10+'abc')  # TypeError: unsupported operand type(s) for +: 'int' and 'str'

2. * 运算符
"""
字符串1*整数: 字符串重复多次
"""
print('abc'*3)

3. 所有的比较运算符
str1 = 'abc'
print('abc' == str1)
print(str1 != 'ab')

比较大小
"""
str1 > str2; str1 < str2
让str1中的每一位的字符，分别和str2中每一位的字符依次比较。
直到不同为止，再看不同字符中谁的编码值大或者小
"""
print('dbcd' > 'abcde')
print('二' > '余婷')
print(ord('二'), ord('余'))   


4.in 和 not in
"""
str1 in str2: 判断str1是否在str2中(str2是否包含str1 / str1是否是str2的子串)

结果是布尔值
"""
print('abc' in 'a1b2cdefg')
print('f' not in 'python')  

5.获取字符串长度
# 字符串的长度，指的是字符串中字符的个数
# len()内置函数
str3 = 'project'
print(len(str3), len('abc 123\n'))

补充：空串
str4 = ''
str5 = ""
print(len(str5))

len1 = len(str3)   # len1 = 7
index = len1 - 1   # 6
print(str3[-1], str3[index])    


6.阻止转义
# 在字符串的最前面添加r/R可以阻止转义
print('a\nb','a\nb\\')
print(len('a\nb\\'))   # 4

print(r'a\nb',R'a\nb\\')
print(len(r'a\nb\\'))  # 6


print('a\\nb\\\\')  # a\nb\\
print('\\\n\\')  # \换行\

print(r'\\\n\\')  # \\\n\\  

3.6 字符串的相关内置方法（略）

4.分支与循环

4.1.数据类型转换

'''
 int, float, bool, str
# 1.数据类型的自动转换
a = 10  # 整型(int)
b = 12.5 # 浮点型(float)
result = a + b  # 会自动将整型a,转换成浮点型，然后再计算
print(type(result))

result2 = a + True   # 会自动将布尔True,转换成整型1
print(result2, type(result2))

# 2.强制转换
# 基本语法：类型名(需要转换的数据)
# a.将其他数据转换成int类型
'''
浮点型、布尔和部分字符串可以转换
'''

print(int(12.55))   # float -> int: 去掉小数点和小数点后面的数
print(int(True), int(False)) # bool -> int: True为1，False为0

去掉字符串的引号后，字符串的内容本身就是一个整数的时候，才能被转换成整型


# b.将其他的数据类型转换成float类型
"""
整数，布尔和部分字符串可以转换
"""
print(float(True), float(False))  #bool-> float: True:1.0, False:0.0

去掉引号后，字符串的内容本身就是一个整数或者浮点数的时候，才能被转换成浮点型
print(float('2e3'), float('-12.5'), float('100'))  


c.将其他的数据类型转换成bool
"""
所有的数据类型的数据都可以转换成bool

数字中：除了0是False,其他的都是True
字符串中：除了空串，其他的都是True

总结：所有为空、为0的值全部是False。否则就是True

"""

print(bool(0.0000))
print(bool(''))
print(bool([]))
print(bool({}))
print(bool(None))

d.其他类型转换成字符串
"""
所有的数据都可以转换成字符串。转换的时候就是在数据的外面加引号
"""
print(str(100), str(18.9), str(True), str([1,2,3]))
'''

4.2 if分支

'''
# python中的分之结构只有一种：if分之结构
"""
1. if

语法：
if 条件语句:
    执行语句块

其他语句

说明：
a. if: python中的关键字，'如果'的意思,用来做判断
b. 条件语句: 最终的结构会被转换成布尔值
c. 冒号: 冒号是固定写法，必须写！
d. 执行语句块：这儿可以是多行语句，但是每行语句必须和前面的if保持一个缩进(一个tab)

执行过程：先判断条件语句的结果是否为True,如果为True就执行冒号后面的执行语句块。
        否则直接执行if模块后的其他语句

"""

age = 10

if age >= 18:
    print('成年')
    print('可以进网吧')  

# 练习：用一个变量保存一个学生的成绩，要求：当学生的成绩大于90的时候，打印优秀。
#      不管成绩是多少，都把成绩打印出来
score = 99

if score > 90:
    print('优秀')

print(score)


"""
2. if-else
语法:
if 条件语句:
    执行语句块1
else:
    执行语句块2

其他语句

说明：
else: 关键字（else后边的冒号不能省）

执行过程：先判断条件语句的结果是否为True,如果为True就执行执行语句块1，
         执行完语句块1后再执行其他语句；如果为False就执行语句块2，
         执行完语句块2后再执行其他语句
"""
# 要求年龄大于等于18就打印成年，否则打印未成年
age = 12

if age >= 18:
    print('成年')
else:
    print('未成年')
    print('不能进网吧')  


"""
3.if-elif-(else)

语法:
if 条件语句1:
    语句块1

elif 条件语句2:
    语句块2

elif 条件语句3:
    语句块3

    ...
else:
    语句块n

其他语句

"""
# 要求成绩大于90分打印优秀，80-90打印良好，60-79及格，60以下不及格
score = 50

if score > 90:
    print('优秀')

elif score >= 80:
    print('良好')

elif score >= 60:
    print('及格')

else:
    print('不及格')



"""
4.if语句的嵌套
每个if分之中都可以嵌套其他的if语句

if 条件1:
    执行语句1
    if 条件2：
        执行语句2
    else:
        执行语句3
else:
    执行语句4


"""
# 成绩和年龄：如果成绩大于等于90并且年龄是18以上就获取 奖金100万，
#           年龄小于18就获取奖金200万。成绩小于90不管多少岁打印没有奖金
score = 90
age = 18
if score >= 90:
    if age >= 18:
        print('100万')
    else:
        print('200万')
else:
    print('没有奖金')

# 练习: 产生一个随机数(0-100)，判断随机数是否是偶数，如果是打印偶数，否则打印奇数。
#      如果能够被4整数，再打印能被4整除
import random
number = random.randint(0, 100)
print('随机数是:%d' % (number))

if number % 2 == 0:
    print('偶数')
    if number % 4 == 0:
        print('能够被4整除')
else:
    print('奇数')


# 补充：
# import是python中导入模块或者模块中内容的关键字
# random是python内置的产生随机数的模块

number = random.randint(10, 20)  # 产生一个10到20的随机整数，并且存到number中
print(number)
'''
条件语句的简写
'''
# 判断一个数是否是偶数的两种写法
number = 11

# 初学者
if number % 2 == 0:
    print('偶数')


# 推荐
if not number % 2:
    print('偶数')


if number % 2:
    print('奇数')
else:
    print('偶数')


# 判断一个字符串是否是空串
# 初学者
str1 = 'abc'

if str1 == '':
    print('是空串')
else:
    print('不是空串')


if len(str1) == 0:
    print('是空串')
else:
    print('不是空串')


# 推荐
if str1:
    print('不是空串')
else:
    print('是空串')

if not str1:
    print('空串')
else:
    print('不是空串')
'''

4.3.for 循环

'''
# 1+2+3+4+5+....+100
# 在完成某个功能的时候，如果需要重复某个操作，就可以使用循环。
# python中循环结构有两种：for循环和while循环

"""
1.for循环的结构:
for 变量名 in 序列:
    循环体

说明：
a.for: 关键字
b.变量名: 和声明变量时的变量名的要求一样
c.in: 关键字
d.序列: 容器(数据本身是由多个数据组成)，
       例如：字符串、列表、字典、元祖、集合、range、生成式和生成器（迭代器）
e.循环体：需要重复执行的代码

执行过程：
    让变量去序列中取数据，一个一个的取，取完为止。每取一个数据，执行一次循环体

# range函数是python中内置函数，作用是产生指定范围中的数字
# xrange是python2中的函数，python3中用range来代替了
"""
range(N): 产生0 ~ N-1的所有整数
range(N,M): 产生 N ~ M-1的所有整数
range(N,M,step): 产生从 N开始，每step产生一个整数,到M之前
"""


'''

4.4.while循环

'''
"""
1.结构:
while 条件语句:
    循环体

2.说明:
while: 关键字
条件语句: 结果是True或者False
循环体: 要重复执行的代码

3.执行过程:
判断条件语句的结果是否为True, 如果为True就执行循环体，
执行完循环体再判断条件语句是否为True,如果为True就执行循环体....
直到条件语句的结果为False为止
"""

# for循环和while循环的比较：
# for循环循环次数是有限的，并且是固定(确定); while循环的循环次数不确定
# for循环: 1.遍历序列中的值 2.循环次数确定
# while: 1.死循环  2.循环次数不确定
'''

4.5.break和continue

'''
"""
break和continue放到循环体有特殊的功能

break: 程序执行到break, 整个循环直接结束，然后执行循环外面的其他的语句
continue: 循环体中遇到continue，结束当次循环，进入到下次循环的判断。

for x in 序列:
    语句1
    语句2
    continue/break
    语句3

其他语句

while 条件:
    语句1
    语句2
    continue/break
    语句3

其他语句

"""
'''

补充

'''
```python
'''
input()
1.程序遇到input,会停下来，等待输入完成后才会执行后面的代码（阻塞线程）
2.输入结束，遇到return就结束
3.获取到的内容是字符串（无论输入什么）
'''

break,continue,else

'''
break:程序过程中，只要遇到break，
就结束/跳出包含break的最近的一个循环

'''
#练习：随机生成一个整数，然后去猜，猜中为止
import random

random_number = random.randint(0,100)

while True:
    input_number = int(input('请输入一个0~100的数：'))
    if input_number == random_number:
        print('恭喜猜对了')
        break
    elif input_number > random_number:
        print('输入的数字大了')
    else:
        print('输入的数字太小了')
'''
请输入一个0~100的数：22
输入的数字太小了
请输入一个0~100的数：66
输入的数字大了
请输入一个0~100的数：44
输入的数字大了
请输入一个0~100的数：33
输入的数字大了
请输入一个0~100的数：36
输入的数字大了
请输入一个0~100的数：25
恭喜猜对了结果：

'''

sum = 0
for x in range(0,1001):
    if not x % 15:
        continue
    sum += x
print(sum)

'''
else:python中的循环的最后可以添加else语句，代表循环结构后要执行的代码
注意：写到else里面的语句，和卸载循环外面你的区别是。break的时候，else里面的不会执行
'''
(1)
for x in range(6):
    print(x)
else:
    print('else的作用')

(2)
n = 1
while n <= 5:
    print(n)
    n +=1
else:
    print('else的作用')
'''
0
1
2
3
4
5
else的作用
'''

2.print的使用

a.print(内容一)

print('内容') #打印完会换行
print(变量)
print(str,a,b,c) # 多个内容，每个内容空格隔开

b.打印后换行

print(内容，end='\n')  #默认是end='\n'，所以产生了换行
print(内容，end='')   #不换行
print(内容，end=',')   #不换行，以逗号分隔

c.设置同时打印多个内容，内容之间的样式

print(a,b,c,sep='')  #默认是sep=''，每个以空格隔开
print(a,b,c,sep='x') #每个内容以x隔开