1.基础知识

注释：单行注释、多行注释

# 这是一个单行注释,为了保证注释的格式，在#之后通常添加一个空格
print("hello")  # 如果把注释和代码写在同一行，最好在代码之后打两个空行，在家注释
"""
这是多行注释   （多行注释和可换行的字符串是一样的，不过字符串需要定义一个变量进行接收）
多行注释
"""
print("hello2")
'''
这也是多行注释
'''
print("hello3")

以上就是Python中的注释方式了。

算术运算符

除了 + - * / 还有以下常用的运算符。

# 其他运算符
print(9 // 2)  # 整除 ，向下取整（取比较小的整数）
print(9 % 2)  # 取余数
print(5 ** 3)  # 幂函数，5的三次方
print("ab" * 10)  # 注意：乘法还可以进行字符串运算，10遍ab字符拼接。

//表示整除，向下取整。

% 表示取余数，和java中的用法一样。

**幂函数，可以用于乘方计算。

注意：如果字符串中使用*，则表示字符串重复的次数。

变量的定义

变量的定义主要有两种方式：

（1）：变量名 = 值

（2）：变量名 = 公式

"""
变量的定义： 变量名=值 或者 变量名=公式
"""
qq_number = "123456"
print(qq_number)  
price = 8.5
weight = 7.5
money = price * weight
print("金额为:", money)

和Java不同的是，Python是动态类型的语言，不需要指定数据类型，这也是Python的方便之处。

Python数据类型

由于python是动态类型的语言，其数据类型只分为数字型和非数字型。

注意：Python2当中还有long数据类型，但是Python3中把int和long都整合到int中了。Python2 中是没有布尔型的，它用数字 0 表示 False，

          用 1 表示 True。到 Python3 中，把 True 和 False 定义成关键字了， 但它们的值还是 1 和 0，它们可以和数字相加。

注意：数字类型、字符串类型和元组类型是不可变类型，列表，集合和字典类型是可变的。

定义变量时不需要指定变量的类型因为在运行时Python的解释器会根据赋值语句等号右侧的数据自动推导出数据的准确类型

name = "小明"  # 字符串类型str
age = 18  # 整型int
sex = True  # 布尔类型 bool,真True假False
height = 1.75  # float,表示小数类型
weight = 75.0  # float

# 注意python中允许连续赋值
a = b = c = d = 1  # 创建一个整型对象，值为 1，从后向前赋值，三个变量被赋予相同的数值。
e, f, g = 1, "str", 444.3  # 创建多中类型的对象，分别对多个变量赋值

"""
1.使用type()函数可以查询对应的数据类型,使用isinstance(变量，类型)可以判断是否为该类型
2.type() 不会认为子类是一种父类类型，而isinstance()会认为子类是一种父类类型
"""
print(type(age), type(sex), type(name), isinstance(height, float))
print(True + False)  # 1+0
print(True + True)  # 1+1
print(10 + 1.2 + True, type(10 + 10.2 + True))
print("syw" + "9" * 3 + "lmy")
print(int("120") + isinstance(int("120"), int))  # 把字符串转换为整型 这里会输出121，因为120+True为121
print(str(666), type(str(666)));  # 这里无法进行字符串拼接，因为type(str(666))为type类型的数据
print(str(666), type(type(str(666))));  # 把str(x) 把x转换为字符串类型的数据
print("我爱" + "编程")  # 字符串的拼接
print(eval("3+6"))  # eval(str)  可以直接计算一个表达式的值

输入和输出

注意：输入使用的是input()函数，可以在括号内添加输入的提示信息，注意使用input函数获得的输入都是字符串类型。

# x = input("请输入苹果的个数：")
# y = input("请输入苹果的单价：")
# print(x, type(x), int(x), float(y), type(float(y)))

# 改进版
name = input("请输入要购买苹果的姓名：")
x = int(input("请输入苹果的个数："))
y = float(input("请输入苹果的价格："))
print("需要支付的金额：", x * y)
"""
格式化输出  %s(字符串),%d（十进制整数）,%f(浮点数) %%(输出百分号)
%06d,表示输出的整数位数，不足的补0，如果写成%6d,此时如果不足就补空格
%.2f 表示小数点后面显示两位(会自动的四舍五入)
"""
print("%s需要购买苹果" % name)
print("购买苹果的个数为%04d" % x)
print("%s购买苹果需支付的金额为 %.2f" % (name, x * y), "元钱")
temp = 0.2
print("百分之二十：%.2f%%" % (temp * 100))
"""
Python变量的命名规则:不能以数字开头，不能使用关键字
只能使用字母数字下划线
如果变量名由两个或者多个单词组成时，需要使用_分割，例如：qq_number,
或者使用驼峰命名法,例如userName,这是小驼峰，UserName,这是大驼峰（所有单词的首字母都大写）
"""
print(keyword.kwlist)  # 查看Python的关键字

注意：Python也支持格式化输出内容，和其他高级类型的语言一样。

字符串操作

# coding=utf-8
import keyword
"""
-----------字符串操作以及转译字符-------
"""
str1 = '我是第一个字符串'  # 单引号定义的字符串必须在同一行
str2 = "我是第二个字符串"  # 双引号定义的字符串也必须在同一行
# 三个引号定义的字符串可以不在同一行，按照对应的格式进行原样输出
str3 = """        
我是第三个
字符串
我可以换行
"""
# 这里的\为转义字符中的续行符号，上下两部分内容其实都是在同一行
str4 = "abc" \
       "defg"
str5 = "我觉得学习python\n很有意思"  # \n表示换行符
str6 = r"没有退路了\t必须要好好学习"  # 前面的r表示原样输出，无视\t这个一个tab的转译字符，如果去掉r则会有一个tab的缩进
print(str1)
print(str2)
print(str3)
print(str4)
print(str5)
print(str6)
"""
注意：字符串可以直接按照字符数组的方式进行截取
   abcdef
   012345
   -6,-5,-4,-3,-2,-1
   注意：截取是一个前闭后开区间
   1.截取的时候如果是同正或者同负，前面的索引不能比后面的索引值大，
   2.不允许前面是负数后面是正数
   3.如果前面是正数，后面是负数的时候，截取时候从前面的索引开始，到后面的索引，但是不包括后面的索引
"""
a = "abcdefg"
print(a[0:-1])  # abcdef，从第一个字符到最后一个字符，但是不包括最后一个
print(a[2:])  # 从三个开始到最后一个（闭区间） cdefg
print(a[-4:])  # 从索引为-4的地方到最后一个（闭区间） defg
print(a[1:4] + "测试")
print(a[0:-2])
print(a[2:-2])
print(a[-1:-4])  # 不支持
print(a[-4:-1] + "测试")
print(a[-1:2])  # 不支持
"""

注意：

Python字符串的拼接建议使用逗号直接拼接。例如：

  abc="123"
  print("fff",abc)  # 带有变量的拼接
  print("aaa","bbbb")  # 不带变量的拼接
  不带变量的拼接可以使用+进行连接，但是还是建议使用逗号

2.条件和循环语句

if else 条件

这是最简单的条件判断，只有一个if和一个else。

age = int(input("请输入年龄"))
if 0 <= age <= 100:
    print("年龄,%d岁" % age)
else:
    print("输入错误")

if elif else条件

这种方式类似java中的if ，else if， else。

score = int(input("请输入成绩:"))
if 0 < score < 60:
    print("不及格")
elif 60 <= score < 80:
    print("及格")
elif 80 <= score < 90:
    print("良好")
elif 90 <= score < 100:
    print("优秀")
else:
    print("成绩输入错误")

两种条件的嵌套

# 判断语句的嵌套
age = int(input("请输入年龄"))
if 0 <= age <= 100:
    if age < 18:
        print("%d未成年" % age)
    elif age < 30:
        print("成年")
    elif age < 40:
        print("而立")
    elif age < 50:
        print("不惑")
    else:
        print("年龄太大了,%d岁" % age)
else:
    print("输入错误")

上面是对两种常用循环的嵌套。

"类"三目运算符

这种方式相当于上面条件表达式的化简，和Java中的  a>b?c:d 用法类似。

# 条件表达式的简化
temp1 = 12
temp2 = 22
r = temp1 if temp1 > temp2 else temp2
print("最后的结果为：%d"%r

r在temp1大于temp2的情况下为temp1，其余情况下为temp2。

While循环

格式为 while 条件：

                    循环体

pos = True  # 循环条件
count = 0
while pos:
    if count < 10:
        count += 1
    else:
        pos = False
print("循环的结果为" + str(count))
print("另外一种表达为%d" % count)

For循环

for 循环
for 迭代变量 in 对象:       #注意如果是数字的话，则不包括最后一个数字，是小于的关系不是小于等于
     循环体

# range函数(start ,end ,step) start表示开始的值，end表示结束的值，step表示步长
print("求前一百个数的和")
result = 0
for i in range(101):   # range(0,101,1) 和 range(101) 等价 ，相当于 i每次都等于range生成的数
    result += i
print("最后的结果是" + str(result))

# 遍历字符串
str2="syw你是最棒的"
for ch in str2:
    print(ch)

循环嵌套

就是两个循环放一块，和java类似

for i in range(1,10):
    for j in range(1,i+1):
        print(str(i)+"*"+str(j)+"="+str(i*j),end='\t')   #这里的end=''可以阻止print函数的自动换行,如果使用end='' ,表示隔开一个空格，end='\t'表示后面接一个tab
    print()     #换行

到此常用的循环和条件判断就结束了。

3.逻辑运算和位运算

逻辑运算

与and  或or  非not,注意要和 & ,| ~区分开，后者是位运算

a = 1  # 01
b = 2  # 10
print(a & b)  # 0，因为01和10做与运算为0
print(a and b)  # 2,如果a,b都是非零数字，则返回后面的那个数
print(a or b)  # 1 ,如果a,b有一个或两个非零数字，则返回第一个非零数字
a = 3
b = 0
print(a and b)  # 0,如果a,b中含有0时返回0
print(not a)  # False,a为非零数为True,not a为False
print(not b)  # True,b为0，not b为True

a = int(input("请输入成绩1："))
b = int(input("请输入成绩2："))
if not (a >= 80 or b >= 80):
    print("成绩不合格")
else:
    print("成绩合格")

print("超市正在打折\n快来抢购吧")
date_input = input("请输入你要去的时间（如星期一）：")
date_time = int(input("请输入详细的小时："))
# 在Python中，默认是按照ASCII的大小比较的，即从字符串的第一个字符进行比较，如果相等，
# 则继续比较下一个字符，直到分出大小，或者还没分出大小，有一个字符串已经到头了，那么较长的那一个字符串大。
if not date_input == "星期日" and (date_time > 8 or date_time < 6):
    print("您处于打折的时间")
else:
    print("对不起，当前时间不在打折")
# 石头剪刀布的游戏，使用随机数：需要导入random包 import random，
# 注意导入包的代码最好放在最上面
player = int(input("请输入，1：石头，2：剪刀，3：布"))
computer = random.randint(1, 3)  # 电脑随机生成1到3的整数，包括1和3，注意：前面的整数应当小于或者等于后面的
print("玩家的选择是%d,电脑的选择是%d" % (player, computer))
if ((computer == 1 and player == 3)
        or (computer == 2 and player == 1)
        or (computer == 3 and player == 1)):
    print("玩家获胜")
elif computer == player:
    print("平局")
else:
    print("电脑获胜")

注意，这里和java中的区别还是挺大的，python使用英文单词进行逻辑运算，而java常用符合来进行逻辑运算。

位运算

&(按位与) ，|(按位或)，^(按位异或：相同为0，不同为1)，
~(取反运算符)，<<左移运算符(相当于乘以2的n次方) , >>右移运算符（相当于除以2的n次方）

print("12&8 = " + str(12 & 8))
print("31^32 = " + str(31 ^ 32))
print("~123 = " + str(~123))
print(48 >> 4)  # 右移 48/(2的四次方)
print(48 << 10)

注意，这里的符号是进行位运算的，不是进行逻辑运算的，这点要分清楚

4.异常处理

和java不同的是，这里并不是try， catch ，finally，而是 try  ，execpt， finally。

    try:
        r = requests.get(url,timeout=3)  
        r.raise_for_status() 
        r.encoding='utf-8'
        return r.text 
    except BaseException as e:
        print("出现异常", e)
    finally:
        print("返回结束")

这里BaseException类似于Java的Exception，是所有异常类的基类。

5.序列（元组、列表、集合、字典、字符串）

序列结构主要包括如下五种：列表，元组，集合，字典和字符串
注意：以下内容五种类型通用
序列中每一个元素都有一个编号（索引）  0,1,2,...n-1   或者 -n,-(n-1),...,-2,-1。
切片：序列名[start:end:step], start表示切片开始的位置默认为0，end表示切片截止的位置，默认为序列的长度,step 如果省略默认为1，最后的：也可以省略。
相加：两个序列相加不会去掉重复元素,第二个默认追加到第一个序列的后面。,注意：相加必须同为列表，元组等，相同的数据类型
相乘：类似字符串的乘法，*n表示重复n次
检查某个元素是否为序列中的元素 : value in 序列
长度，最大值，最小值，求和： len(序列名)，max(序列名),min(序列名),sum(序列名)
排序：sorted(序列名，key=None,reverse=False)这个排序是默认返回一个新的序列,key表示用于比较的键，reverse表示是否倒序
反转：reversed(序列名)反转之后是一个对象的类型，需要使用list()函数转换为list
enumerate() 函数：将序列组合为一个索引序列，一般用在for循环中

列表

列表的创建方式：

# 1.直接复制一个列表给一个变量  ls=[1,2,3]
# 2.创建空列表  ls=[]
# 3.使用list()函数创建列表

l1 = ["李白", "韩信", "赵云", "鬼谷子", "诸葛亮", "孙尚香", "公孙离"]
print(l1[2])  # 输出第三个元素
print(l1[-len(l1)])  # 输出第一个元素 -n

# 切片的使用
print(l1[0:len(l1):2])  # 从第一个到最后一个，步长为2
print("逆序：",l1[::-1])  # 步长为负数表示逆序
print(l1[:len(l1)])  # 注意第一个冒号不能省略，从第一个开始，到最后一个，默认步长为1
print(l1[:3])  #从头开始截取到第二个，步长为1（默认），共三个数
print(l1[::3])  #步长为3，截取所有

相加的使用：

l2 = ["李白", "姜子牙", "干将莫邪"]
l2[1] = "鲁班七号"  # 修改内容
del l2[2]  # 删除第二个元素 “干将莫邪”
print(l1 + l2)  # 两个列表的相加
l3 = [1, 8, 13, 7]
print(l2 + l3)  # 两个不同数据类型的序列相加
print(l3 * 3)  # 序列乘法

检测元素是否在列表中：

print("孙尚香" in l1)
# 长度，最大值，最小值,求和
print(len(l3), max(l3), min(l3), sum(l3))
l4 = sorted(l3)  # 这个排序是默认返回一个新的序列
l5 = reversed(l3)  # 反转之后是一个对象的类型，需要使用list()函数转换为list
print(sorted(l2), l4, list(l5))
# 使用list()函数创建列表,一般是使用range对象创建列表
print(list(range(1, 10, 2)))

列表中常用的函数
1 ：list(元组) 将元组转换成列表
2 ：l1.append(obj)  在列表的尾部追加元素
3 ：l1.insert(index,obj) 将obj插入到index位置中
4 ：l1.count(obj) 统计某个元素在列表中出现的次数
5 ：l1.extend(seq) 在列表中追加另一个序列
6 ：l1.index(obj) 返回第一次查找到该值的索引
7 ：l1.pop() 默认移除最后一个元素，并返回其值
8 ：l1.remove(obj) 移除第一个匹配的值
9 ：l1.reverse()  与reversed(l1)不同，这个是对当前列表进行反转，并不会返回新的列表
10：l1.clear()  清空列表
11：l1.sort() 默认升序排序， l1.sort(reverse=True) 降序排序

插入、删除和反转：

l6 = ["赵云", "韩信", "李白", "露娜"]
l6.append("白起")  # 在末尾追加元素
l6.insert(1, "宫本")  # 在第二个位置插入元素
print(l6)
l6.reverse()  # 列表反转
print(l6.count("白起"), l6.count("孙悟空"))
print(l6)
l6.remove("宫本")
print(l6)
print(l6.pop(2))
print(l6)

遍历列表中的元素：

# 遍历列表中的元素
for item in l6:
    print(item + "\t", end="")  # 不换行输出
print()
l6.sort(reverse=False)  # 不使用降序
print(l6)
# 遍历输出索引和对应的值,使用enumerate() 函数：将序列组合为一个索引序列，一般用在for循环中
for index, item in enumerate(l6):
    if index % 2 == 0:
        print(str(index) + ":" + item + "\t", end="")  # 偶数不换行,遇到奇数开始下一行
    else:
        print(str(index) + ":" + item)

使用表达式创建列表

使用列表推导式快速创建一个列表
1. ls=[表达式 for 变量 in range]
2. ls=[表达式  for 变量 in 已存在的列表] ,用于在愿列表的基础上生成新列表
3. ls=[表达式 for 变量 in 原列表 if条件表达式]

如下所示：

# 第一种
ls1 = [random.randint(10, 100) for i in range(10)]  # 在10到100中随机找十个数
print("第一种", ls1)
# 第二种
ls2 = [10, 20, 30, 40]
ls_2 = [int(x * 0.5) for x in ls2]
print("第二种", ls_2)
# 第三种
ls3 = [x for x in ls2 if x > 20]  # 挑选ls2中 大于20的数
print("第三种", ls3)

二维数组：

# 使用for循环创建一个二维列表,4行5列
arr = []
for i in range(4):
    arr.append([])  # 在空间表中再添加一个空列表，用于构成二维列表类似于 [[],[],[]]
    for j in range(5):
        arr[i].append(j)  # 每一行的一维列表都是从0到4的一个序列

print(arr)
# 使用第二种方式(列表推导式)创建一个二维列表
arr2 = [[j for j in range(5)] for i in range(4)]
print(arr2)

元组

1，元组不可变(不能添加，修改和删除)
2，元组中的内容可以是多种类型(包括元组，列表等)的，不要求同一种类型
3，元组使用（）

元组的定义：

tup_null = ()  # 空元组 可以用来传递空值
tup = (1, 2, 3, 4, 5, "syw")  # 第一种定义元组的方式
tup1 = ("lmy",)  # 只有一个元素要用逗号隔开,要不然会被认为是单个变量类型，而不是元组类型
tup1_1 = ("lmy")
tup2 = "hahah", "wozhend", "henu", "love"  # 第二种定义的方式
# 数值元组，和创建数值列表的方式一样
tup_num = tuple(range(1, 10, 2))

元组的查看：

print(tup_null, type(tup_null))
print(tup)
print(tup_null == False)  # 不为false
print(tup1, type(tup1), type(tup1_1))
print(tup2)
print(tup_num)  # 打印数值元组
print(tup[2])  # 从左向右访问第三个
print(tup[:3])  # 打印前三个元素，不包括第四个

元组的创建、添加、修改、查询、删除等操作：

# 遍历元组
for index, item in enumerate(tup):
    if index % 2 == 0:  # 每两个换一次行
        print(item, "\t", end="")  # 这里不能使用 item+"\t" 因为item可能不是字符串类型的
    else:
        print(item)

# 修改元组 ：只能对元组重新赋值
tup1 = (1, 4, 5)
tup1 = (6, 7, 8)
print(tup1)
# 元组的链接,只能链接元组
tup1 += (9,)  # 元组的链接
print(tup1)
# 元组推导式创建元组
# range(10)等价于 range(0,10,1)  ,从0开始，到10结束（不包括10），步长为1
tupres = (random.randint(10, 100) for i in range(10))
print("生成的元组是", tupres)  # 注意，这里和序列不一样，这里使用推导式得到的不是一个元组，而是一个生成器对象
print("转换后的元组", tuple(tupres))  # 使用tuple转换为元组
numtup = (i for i in range(5))  # 创建一个元组的生成器对象
print(numtup.__next__())  # 每次访问一个元素，生成器向后移动一次（每次遍历的时候原来的生成器都会发生变化）。
print(numtup.__next__())
for i in numtup:
    print(i, end=" ")
#  结论：无论使用什么方式遍历，原来的生成器对象都已经不再了，如果再想使用该生成器对象，都必须重新创建一个生成器对象

集合

集合和列表与元组不同，集合不能使用下标获取，但是可以通过enumerate函数来遍历的同时获取到下标
创建集合 集合和字典一样，都使用{}括起来，集合分为可变集合（set）和不可变集合(frozenset)
集合中不能存放重复元素，会自动去重的,set里面不能存放list []类型的以及字典类型的{}, 但是可以放元组类型的

集合的创建和遍历：

s1={'syw','lmy','syw','999','lmy',('test','love')}
print(s1,type(s1))
for item in s1:
    print(item,type(item))

for index,item in enumerate(s1):
    print(index,item)
# 使用set函数创建
s2=set("syw520lmy")  # 如果是字符串，则把字符串拆分成不重复的字符集合
s3=set([1,2,3,4])  # 把列表转换为集合
s4=set(('123','456'))  # 把元组转换为集合
s5=set()
print(s2)
print(s3)
print(s4)
print(s5)  # 注意创建空集合只能这样，不能使用{},因为{}表示一个空字典

集合元素的添加删除以及交集、并集、差集：

s5.add('我是添加的syw')
s5.add('天才')
print(s5)
s5.remove('天才')
print(s5)
#  集合的交集，并集和差集
ss1={'syw','520','lmy','999','666'}
ss2={'syw','520','lmy','999','777'}
print("交集为:",ss1 & ss2)
print("并集为:",ss1 | ss2)
print("ss1-ss2的差集为:",ss1-ss2)
print("ss2-ss1的差集为:",ss2-ss1)

字典

1.字典通过键来读取，而不是索引
2.字典是无序的
3.字典中的键必须唯一
4.字典中的键必须是不可变的，可以是字符串，数字，元组，但是不能使用列表
5.字典是可变的，可以增长或者缩短

字典的创建：

# 创建空字典
d1 = {}
# 或者使用dict()函数
d2 = dict()
# 正常方式创建一个字典
d3 = {"test1": 123, "t2": 666, 555: "sdf"}  # 这里不是使用赋值方式创建字典，所以冒号两边的类型不要求是变量
d3_2 = dict(syw='老公', lmy='老婆')  # 注意：这里与上面不同，这里使用=创建，这里key相当于一个变量，你肯定不能使用一个字符串作为key吧。
print(d1, d2, d3)
# 使用映射函数创建字典 d4=dict(zip(list1,list2)),这里的list1表示的是键的列表，list2表示值的列表
name = ['syw', 'lmy']
sign = ['仆人', '主人']
d4 = dict(zip(name, sign))
print(d4)
# 使用推导式创建字典
d4_2 = {i: random.random(80, 100) for i in range(5)}
print(d4_2)
d4_3 = {i: j for i, j in zip(name, sign)}
print(d4_3)

通过键获取值

print(d3_2['syw'])
print(d3[555])
print(d3['t2'])
print("通过get方法查询:", d4.get('syw', 'hahah'))  # 这里使用的是带有默认值的get方式查询，如果没有找到键为'syw'的数据，则自动返回'hahah'这个字符串
#  注意：为了防止要查找的键不存在时会报错，可以进行如下处理
print("查询的结果是:", d3_2['lmy'] if 'lmy' in d3_2 else '字典中没有这个键')

循环遍历字典

# 使用字典对象的items()方法可以获取字典的 "键值对"列表
for item in d4.items():
    print(item, end="\t")
# 分别获取字典的键和值
print()
for key, value in d4.items():
    print(key, ":", value)
# 使用values()和keys()分别获取对象的键和值的列表
for key in d4.keys():
    print(key, end="\t")
print()
for value in d4.values():
    print(value, end="\t")

print()

字典的添加

d5 = dict((('test1', 'syw'), ('test2', "999"), ('test3', 'lmy')))
print(d5)
d5['test4'] = '999'  # 添加一个元素
print(d5)
d5['test4'] = '99999999'  # 修改字典中的一个元素,需要键已经存在
print(d5)
del d5['test4']
print(d5)

基础内容到此就结束了，如有缺失，后续会补充。