python基础是个什么鬼？

     作为初入坑python的小测试，摸黑做个笔记。

变量名的规则

1.变更名是由字母(大小写的A-Z)、数字（0-9）、下划线（_）组成

2.变量名不能以数字开头

3.变量名是区分大小写的

切记！！！！变量名的命名规范：驼峰式命名法

python常见的数据类型

    python支持自动识别数据类型。测试狗子们掌握下面三种基本的数据类型已经够够的啦：

1.数值：包括整数、浮点数（小数，只要带小数点的都算），只要带浮点数得出来的结果都是浮点数

2.字符串：str()，这个不用多说，直接看连接吧字符串_百度百科

3.布尔值：一般用来做条件判断，返回得结果是True或者False。简单得举几个栗子：

bool()函数里面的零值是False，非零值是True

任何非空的字符串转化成布尔值都是True

空值转化为布尔值永远都是False(敲黑板，重点哟)

字符串转化成布尔：

str(True) # 结果是'True'
str(False) # 结果是'False'
str(None) # 结果是'None'

数值转换

1.对于数值类型，我们也可以用str()将它们转换为字符串，eg:print("My age is", str(18))

2.要把一个整数字符串转换为int类型，使用int()；int()函数向下取整，int(99)--->输出99

3.要把一个带小数点的字符串转换为float类型，使用float()

ps：float在被转换为int 的过程中，它的小数部分精度将被丢弃，只取整数部分。所以在将float转换为int的过程中，永远要小 心。

4.round()函数，向上取整，且可指定保留小数点后的几位，eg:

round(99.9)--->结果是100

round(3.1415926,2)--->结果是3.14      # 取小数点后的两位

5.布尔值转成int或者float

硬背吧，没有为什么。哈哈哈~~~~

int(True) # 结果是1
int(False) # 结果是0
float(True) # 结果是1.0
float(False)# 结果是0.0
 

运算符

算数运算符

运算符	描述	栗子
+	加	1+1 ; a+b
-	减	2-1 ; a-b-c
*	乘	2*1，相当于2 x 1
/	除	6/2，相当于6 ÷ 2
//	取整除	9/2, 结果是 2
%	取模	10 % 4，相当于 10 - (10 // 4) × 4
**	指数	2 ** 3 相当于 2 * 2 * 2，也就是2的3次方
()	小括号	提高运算优先级，比如: (2 + 8) * 2

敲黑板：

1.除法运算, 当我们使用单 斜杠除法运算符时，即使除数和被除数都是整数，它的返回结果也是一个浮点数。

2.当我们需要对两个整数进行除法运算，且对结果的小数精度要求不高的时候，一般使用双斜杠来进行运 算，这样能保证结果也是整数，不用再进行类型转换。

3.所有的运算符两边都有一个空格，这是Python代码的书写规范。

4.取模运算符大家先暂时可以理解为取余数，记住以下几个规则： 当两个数能整除时，取模运算的结果为0，a % b 就相当于a - (a // b) * b，0不能作为除数，也不能用来取模。

使用算术运算符操作字符串

1.加号可以将两个字符串拼接成一个字符串，也可以将多个字符串拼接在一起：

print("字符串1" + "字符串2" + "字符串3")

2.用"*"运算符，表示将该字符串重复几次并拼接成一个字符串：

print("字符串" * 5)  

3.不能将字符串与数值一起相加，正确的做法是将数值转化成字符串：

print("字符串" + str(数值))

赋值运算符

运算符	描述	栗子
+=	加法赋值运算符	c += a 相当于c = c + a
-=	减法赋值运算符	c -= a 相当于c = c - a
*=	乘法赋值运算符	c *= a 相当于c = c * a
/=	除法赋值运算符	c /= a 相当于c = c / a
//=	取整除赋值运算符	c //= a 相当于c = c // a
%=	取模赋值运算符	c %= a 相当于c = c % a
**=		c = a 相当于c = c  a

日常编程中最常用的是加法赋值和减法赋值,eg:初始值是0，每执行一次+1

count = 0

count += 1

count += 1

比较运算符

      用来运算布尔值的， 将两个值放在一起比较，最后得到True或者False。

运算符	描述	栗子
==	等于	100 == 100
!=	不等于	100 != 90
>	大于	100 > 90
<	小于	90 < 100
>=	大于等于	3 >=1
<=	小于等于	8 <= 9

逻辑运算符

常常需要判断的条件是复杂的，所以我们需要逻辑运算符将多个比较运算连接起来。

# 定义两个变量
a, b = 1, 2
a > b and a < b      # 判断a > b和a < b为True
a % 2 == 0 or b % 2 == 0      # a % 2 == 0或者b % 2 == 0 ，其中一个成立就判断为True
not a > b    # 判断a不大于b，结果为True

流程控制

条件判断

if...else语句

# 把3赋值给num
num = 3

# 通过取模运算num是否能被2整除
if num % 2 == 0:
    # num是数值不能直接拼接字符串，所以用str()函数转化成字符串再拼接
    print(str(num()) + "是一个偶数")  
else:
    print(str(num()) + "是一个奇数")

elif

"elif", 它只能用在if判断之后，else之前。需求：学生的考试成绩，60分以下的为不及格，60~90分为合格，90 分以上为优秀

# 把59赋值给score
score = 59
# 第一个条件是小于60，判断为不及格
if score < 60:
   print("成绩不及格")
# 第二个条件是小于90，判断为及格
elif score < 90:
   print("成绩及格")
# 第三个条件，大于90，判断成绩优秀
else:
print("成绩优秀")

if条件嵌套

      需求：对60~100分的进行更细的划分，60~70分为合格，70~90 分为良好，90分以上为优秀。

# 把100赋值给score
score = 100
# 先判断最>=60，里面嵌套三个条件：大于等于60小于70、大于70小于90、大于90
# 最后判断<=60
if score >= 60:
   if score < 70:
      print("成绩及格")
   elif score < 90:
      print("成绩良好")
   else:
      print("成绩优秀")
else:
   print("成绩不及格")

与逻辑运算结合

# 把22赋值给age
age = 22

# 判断年龄大于18岁并且小于60岁
if 18 < age < 60:
   print("成年人了，搬砖！")

自动类型转换

       if 和 elif 的后面总是跟着一个表达式，这个表达式的结果必须是True或者False，如果表达式运算出来的 结果不是一个布尔值，则会自动将结果转换为布尔值，无论它是什么类型的值。

记住：0值、None 和空字符串转换为布尔值后都是False

循环

while循环

给自己设定了一个目标，跑完就结束，格式如下
while 循环条件：
        循环体

# 执行顺序由上至下
lap = 0

# 循环条件是lap < 10
while lap < 10:
      
      # lap的初始值是0，循环条件是每执行一次加上1
      lap += 1
      
      # 循环体，每执行一次打印一次lap+1圈，直到执行完成10次停下来
      print("我跑完了第" + str(lap + 1) + "圈")

for循环

       for循环可以用来遍历序列，序列指的是一个可迭代的有序的集合，比如字符串就是一个序列，下面我 们用for循环来打印出一个字符串中的所有字符。

# 把字符串apple赋值给seq
seq = "apple"

# 判断s在seq内（注意：此时的字符串是apple）
for s in seq:
    
    # 打印s
    print(s)    #代码执行后输出一次是 a p p l e

嵌套循环

# 需求：在控制台中打印出指定边长的长方形或者正方形图案。

# 指定长方形的宽和高
width, hight = 10, 5

"""
   print函数有了第二个参数，end表示在打印完指定的内容后，在结尾再打印一个指定的字符
串，默认每个print语句在结尾会加一个换行符"\n", 传递一个空字符串给它，表示打印完星号以后不再
添加任何输出内容。第二个print函数没有任何参数，那它会输出一个换行符。
"""

# 从上到下开始遍历打印高度和宽度
for i in range(height):
    for j in range(width):
        print("*", end ="")
print()

break和continue

略过某一次循环或者干脆跳出整个循环

# 需求：使用for循环和continue来打印出10以内的所有奇数相加的式子，并求出它们
的和。

total = 0
for i in range(10):
    if i % 2 == 0:
       continue
    print(i, end = " + ")
    total += i
print(" = %s" % total)



# 关键字break用来打断整个循环并跳出。看这个例子，给一个字符串，这个字符串是一个小数，要求打
印出小数的整数部分。
s = "238.9237834829"
for i in s:
    if i == '.':
       print()
       break
    print(i, end='')

数据结构

字符串格式化

常用的占位符如下

占位符	描述	栗子
%d	整数占位符	给%d传入一浮点数，自动转化成整数： print("%d" % 3.14)--->输出3 print("%d" % 3.99)--->输出3
%f	浮点数占位符	print("%f" % 3.14)--->会输出“3.140000”，后面的0是自动补齐的
%.f	指定精度的浮点数占位符	print("%.2f")--->会输出3.14
%s	字符串占位符	print("%s" % 100) # 输出100 print("%s" % 3.14) # 输出3.14 print("%s" % "python") # 输出python
%%	输出百分号%	在字符串输出一个百分比，就需要用到%% report = "%d年%s公司营收增长了%.2f%%" % (2019, "某某", 20.28) print(report)

format函数

       除了%运算符外，Python还为我们提供了字符串的format函数提供丰富的格式化。比如说，在输出一个 较长的数字时，根据国际惯例，每三位用逗号分隔：

# 每三位用逗号分隔
'{: ,}'.format(1234567890)   #结果 1,234,567,890

字符串的下标和切片

       从左到右：所有的下标都是从0开始的，当我们要访问一个字符串的第1个字符时，使用的下标应该是0。

        从右到左：使用负数下标可以从右往左访问，这种写法是Python特有的，非常的快捷，对于任意长度的字符串，我 们都可以使用-1来获取它的最后一个字符，注意使用负数下标是是从-1开始的，因为-0也是0，产生重复 了。

s = "CHINA"

# 结果是C，取第一位
s[0] 

# 结果是HI,取第一位和第二位，第三位不包含，开区间
s[1:3]

# 结果是CHINA，0可以不写
s[:5] 

# 结果是CHINA，若全部不写就是取全部
s[ : ]

# 结果是INA,从第三位取到尾
s[2:]

# 结果是 CIA,从头到尾隔两个字符取一个 
s[ : :2]

# 结果是AIC,从尾开始取，隔两个字符取一个
a[: : -2] 

# 最后一个字符"A"
s[-1] 

# 空字符串
s[0:0] 

# 倒序输出一个字符串, 结果：ANIHC
s[::-1]

字符串函数

strip()函数

       可以去除字符串中头和尾的空格字符

# 去除字符串中头和尾的空格字符
print("   msfnjsfn sd sda ").strip())

# 想要去除左边的空格
print("  sdsf ".lstrip())

# 想要去除右边的空格
print("  sdsf  ".rstrip())

大小写操作的函数

# upper()函数，可以把字符串变成大写 
print ('china'.upper())

# lower()函数，可以把字符串变成小写
print('CHINA'.upper())

# capitalize()函数，可以把字符串的首字母变成大写
print ('china'.capitalize())

#title()函数，可以把每个单词的首字母变成大写
print ('china i love you'.title())

字符串判断

       字符串判断的函数,返回值是布尔值False True

# islower()函数，可以判断字符串是否是小写
print("china".islower())

# isupper()函数，可以判断字符串是否是大写
print("CHINA".isupper())

# isdigit()函数，可以判断字符串是否是全是数字，应用场景填写的手机号&金额等
print("123456".isdigit())

# startswith()函数, 可以判断字符串是否以XX开头，应用场景特殊格式是否符合需求
print("china".startswith('c'))

# endswith()函数，可以判断是否以指定的字符串结尾
print("china".startswith('a'))

查找和替代

# find()函数，可以找出子字符串，index()函数也有一样的效果，但是没找到的话会报错，一般不用
password = "123"
input_password = " 56612389"
print (input_password.find(password))

# count函数，可以找出字符串中某字母一共出现几次
b = "banana"
print(b.count("a"))

# replace()函数，可以替换字符串中的某一字母或者某一单词
print("aaaddd".replace("a","d")) # --->输出dddddd

# len()函数，可以显示字符串的长度
print(len("china"))

元组

       字符串是一种序列，它可以迭代循环，也可以按索引访问，也可以切片访问。但它的组成只能是单个的字符，现在来介绍一种更多元化的序列：元组，英文叫tuple，是不可变的序列，用于读取，可通过切片和索引访问。

元组定义

# 定义一个元素时，上元组定义的时候也可以不用括号，英文的逗号是必须加的，多个元素可加可不加

# 输出('solo',)
t = 'solo',

# 将一个序列强制转换为元组
tuple('abc') # ('a', 'b', 'c')
tuple(range(5)) # (0, 1, 2, 3, 4)


# 输出('p', 'y', 't', 'h', 'o', 'n')
t = tuple('python')

# 输出('p', 'y', 't', 'h', 'o', 'n')
t = ('p', 'y', 't', 'h', 'o', 'n')

# 输出('p', 'y', 't', 'h', 'o', 'n')
t = 'p', 'y', 't', 'h', 'o', 'n'  

# 定义元组后通过下标索引访问
t = ('My', 'age', 'is', 18)
t[0] # 'my'
t[-1] # 18

# 也可以通过切片来访问，注意切片返回的是一个包含切片片段的新元组。
t[0:2] # ('My', 'age')

# 后面的逗号表明这是一个元组，否则就会被认为是一个字符串。

元组操作

       字符串的另一个函数join，有了它，可以把元组这样的序列拼接成一个整体的字符串。

       元组和字符串都是只读的，也就是不可修改的。我们不能单独改变元组中的某个元素，或者是字符串中的某个字符。

# "".join()：字符串中的连接函数“”里面加空格和不加空格打印出来的格式有区别
# 输出结果：'My age is 18'
t = ('My', 'age', 'is', "18")
print(" ".join(t))

# 元组也支持 in 操作，想要判断元组中是否包含某个元素：
'a' in t # True
'x' in t # False


t1 = tuple("python")

# y在t里面一共出现多少次 ----->输出1
print(t1.count('y')) 

# n在t里面是什么位置----->输出5
print(t1.index('n')) 

# 查看T的长度----->输出6
print(len(t1)) 

遍历元组

        元组属于序列，所以可以像字符串那样去遍历它：

lst = ('a', 'b', 'c', 'd', 'e')
for i in lst:
    print(i)

元组嵌套格式

      一个大的元组里面嵌套小的元组
sales = (
       ("peter",(70,80,90)),
       ("beter",(70,80,90)),
       ("heter",(70,100,90)),
       ("keter",(70,80,90)),
)

定义列表

       定义列表可以理解为可变的元组，它的使用方式跟元组差不多，区别就是列表可以动态的增加、修改、删除 元素。

# 定义了一个空的列表
lst = [] 
lst = list()

# 定义一个带有4个初始值的列表
lst = [1,2,3,4] 

# 列表内定义了字符串、整型、浮点型，元组
lst = ["a",1,2,3,3.14,(1,2,3)] 

# 通过传递可迭代序列：字符串、range()函数、元组转化成列表
lst = list( "asd")
lst = list (range(100))
lst = list ((1,2,3))

# 列表的访问，可通过索引（根据元素的类型返回）、切片(返回的同类的值)访问
lst = ['a','b','c','d','e']

# 通过索引访问第一个和最后一个
print(lst[0],lst[-1])

# 通过切片访问第一个到第三个（不包含），输出结果是['b','c'] 
print(lst[1:3]) 

# 追加函数append（）

# 在列表后面最后面添加'f'
lst.append('f') 

# 查看列表中的长度
print(len(lst)) 

# 修改列表中的函数，可用list索引
lst[0] = 'A' 

# del删除函数
del lst[0]  # 删除列表中第一个元素

列表函数

      列表也是一种序列，它也具有index和count函数和支持len函数，这些函数的用法和元组一样，它的循环遍历也和元组一样。

       下面来介绍一下列表特有的一些函数。

 insert函数：刚刚介绍的append函数一样，用来向列表中添加一个新的元素，区别就是append是在最后添加，insert则可以向任意位置添加。

       在列表任意位置前面插入一个元素，insert(参数1：指定的位置,参数2：需要插入的参数)

lst = ['a', 'c', 'e']

# 在第二个元素'c'前面插入一个字符串'b'
lst.insert(1, 'b')   # lst现在的值是['a', 'b', 'c', 'e']

# 在最后一个元素'e'前面插入一个字符串'd'
lst.insert(-1, 'd') # lst现在的值是['a', 'b', 'c', 'd', 'e']

pop函数：
       从列表内删除最后一个元素，和del不同的地方是会在被删除的同时返回被删除的元素，一般用于取了就用的列表内。

lst.pop()
last = lst.pop()
print(lst,last) # 输出结果：[lst内的元素] 被删除的元素

remove函数

       del操作可删除指定下标索引的元素，如果我们要删除指定内容的元素，就需要用到remove函数。remove函数会从左至右找到与指定的值相匹配的第一个元素，并将它删除。

lst = [1, 2, 1, 'a', 'b', 'c']
lst.remove('a')
print(lst) # lst的值为[1, 2, 1, 'b', 'c']
lst.remove(1) # 注意这里的1是元素值，不是索引
print(lst) # lst的值为[2, 1, 'b', 'c']

clear函数

        会清空列表内的所有元素。

lst = [1,2,3,4]
lst.clear()
print(lst) # 结果为[]

extend函数

        有点像append函数，但append函数每次只能添加一个元素，而extend可以添加一组。可以拓展列表，比append效更高，可一次添加好几个元素

lst = []
lst.extend(range(5))
print(lst) # [0, 1, 2, 3, 4]
lst.extend([5, 6, 7])
print(lst) # [0, 1, 2, 3, 4, 5, 6, 7]

reverse函数：反转函数
lst.reverse() #把lst内的元素反转顺序打印

sort函数

     按照一定的规则将列表中的元素重新排序，对于数值，默认按从小到大的顺序排列。

# lst里面是数字：
lst.sort()  #按照从小到大排序
lst.sort(reverse=True)   #从大到小排序
lst里面是revenue = [('1月',56100000),('2月',46100000),('3月',76100000)]
# 希望按照收入大小来排序，可以引进key参数 = 接收的是一个函数
revenue.sort(reverse= True, key = lamba x: x[1]) #指定让每个元组的第二个索引作为排序依据

ps:对于字符串，则会按照它们的ASCII值的顺序排列。ASCII是基于拉丁字母的一套电脑编码系统，所有的 编程语言都支持ASCII编码。ASCII值一共有128个字符，包含数字0~9，字母a-z, A-Z，还有一些常用的 符号。每一个字符对应一个数字，比如字母'A'对应的就是65， 字母'B'对应66，等等。在Python中，可 以使用内置函数将字符与它的ASSCII值互转。ord()函数可将字母或者数字字符转化成ASCII值，eg:ord('A') ---->输出65

copy函数

      们想要创建一个跟lst1一模 一样的新列表，且不再受它以后操作的影响，就可以使用copy函数：

copy函数
lst1 = [1,2,3]  #lst1里面有数组123

lst2 = lst1 # 把lst1数组的123赋值给lst2

lst1.append(4) # lst1追加多一个4，lst1=[1,2,3,4]

print(lst1,lst2)  #lst1和lst都是[1,2,3,4]

lst3 = lst1.copy() #复制 lst1的值是[1,2,3,4]赋值给lst3

lst1.append(5) # lst追加5，lst3=[1,2,3,4,5]

print(lst1,lst3)   #结果：lst1=[1,2,3,4,5],lst3=[1,2,3,4,]

列表表达式

列表表达式是一种快捷的创建列表的表达式，可以将多行代码省略为一行。比如，列出20以内的所有偶数

lst = [i for i in range(20)] #将遍历20内所有的数作为一个元素组成一个列表

lst = [i for i in range(20) if i % 2 == 0] #在后面加条件，遍历20内所有的偶数

# 另一种写法：
lst = [i *2 for i in range(10) ] # 在前面加条件

# 另一种写法：
lst = [i for i in range(0,20,2)] #利用步长取值，从0开始到20之内，每隔2位取一个值
print(lst)

字典 dict

字典的定义

      使用花括号，可以直接定义字典。每一行冒号左边的是键（key）,右边的是值（value），称作键值对，以逗号分隔开。在这里我们故意写 成每行一个键值对，实际并不要求每行一个，只要用逗号分隔开来就可以。键是不能重复的，值可以重 复。 对于top_sales 这种两个一组、一一对应的列表来说，可以直接转换为字典。

sales = dict(top_sales)
# sales现在的值变成了
{
'Peter': 213,
'John': 253,
'Tony': 284,
'Henry': 205,
'Mike': 280
}

# 语法1：
sales = {
'mike'：123，
'emm'：321，
}

# 语法2：
top_sales = [("mike",123),("emm",321)] # 定义一个变量并赋值列表内的内容给这个变量
print( dict(top_sales)) 

增删查改

# 新增数据：第一步需要设置一个字典里面的值
sales['like'] = 0     # 指定新增一个like=0的数据
print(sales['like'])   # 打印该新增数据的值

# 修改数据：
sales['like'] = 300 # 指定修改like的值修改成300

# 删除数据
del sales['like'] # 删除like的值

遍历词典

       字典的遍历和列表、元组、字符串有所区别，由于它的每一项都是一个键值对，所以在遍历时也要注意。
items()函数：将字典内的内容变成可迭代的序列，以供for循环去迭代
for循环一个个取值，每一个都是一个元组，然后分别将元组内的两个值赋值给两个变量

for key_value in sales.items():
print(key_value)

函数访问字典内不存在的key会报错，取值错误会继续跑代码且返回一个提示

sales.get('不存在的值') # ---->返回none

keys()函数返回所有key的序列

values()函数返回所有的值

# 只想单独列出所有的销售人员名单，可以这样写:
sales.keys()

# 可以对它进行遍历
for sale in sales.keys():
    print(sale)

# 想计算出所有销售人员的销售额总和，也就是公司总销售额，可以直接取出value部分并求和：
sum(sales.values())

集合set

       集合在Python中是一个无序的不重复的序列，一般用来删除重复数据，还可以计算交集、并集等。

# 这两种方式都可定义集合
nums = {1, 2, 3, 4, 5}
nums = set([1, 2, 3, 4, 5])

lst = [1,2,3,4,5,5,1] # 定义一个list的数组
nums = set(lst)  #把lst的传递给一个集合
print(nums) #打印结果是{1，2，3，4，5}

t= ('a','b','c','a') #定义一个元组
print(set(t))  #用set转化t成一个集合
print(list(nums)) #把nums集合转化成list
print(tuple(nums)) #把nums集合转化成元组

# 集合的遍历
for n in nums:
     print(n)
# 查看集合nums的长度
print(len(nums))  

# 用in函数来判断5是否存在集合nums中
print(5 in nums) 

# 用add函数在集合nums中增加一个5，会先判断是否存在，如果存在不会再追加
nums.add(5) 

# remove函数来删除集合nums中的5，如果删除的是nums中不存在的数5会报错
nums.remove(5)    

# 用discard函数来删除集合nums中的5，就算5不存在nums中也不会报错
nums.discard(5)  

# pop函数，删除集合中的某一个值并返回该值,可以一直执行直到集合内为空
num = nums.pop()   

while len(nums) > 0:   #如果集合nums内的长度大于0
    # 一直使用pop函数迭代执行集合nums
    num = nums.pop()   
    # 打印出集合的值
    print(num) 

集合的函数

s1 = {1,2,3，4}
s2 = {3,4,5}
print(s1.intersection(s2)) #求交集，返回{3，4}
s3 = s1.union(s2))  #求并集，返回（1，2，3，4，5）
print(s1.issubset(s3))   #判断是否是子集,返回布尔值True
print(s3.issupperset(s2))   # 判断是否是父集,返回布尔值True

函数

函数的调用与参数   

我们使用def关键字来定义函数

#定义一个函数是hello2,里面有两个参数（里面还可以继续加参数，用，隔开即可）
def hello2(name,sex):   
    if sex == 'boy':      #如果参数sex是boy
        print("Hi,Mr.", name)   #打印出Hi,Mr.参数name
    elif sex == 'girl':  #如果参数sex是girl
        print("Hi, Mrs.",name)   #打印出Hi,Mrs.参数name
hello2('john', 'boy')    #调用hello2,name的值是John，sex的值是boy
hello2('Amy', 'girl')    #调用hello2,name的值是Amy，sex的值是girl
hello2(sex='boy',name='Mike')  #调用hello2,把boy赋值给sex，把Mike赋值给name

函数的返回值

如果将函数比做一名员工，调用函数的我们就是老板，老板给员工一些具体的指示，员工则按规定好的 流程去做事。对于函数也是一样，有一些函数我们是需要知道执行的结果。

ef multiply(num1, num2)  # 定义一个函数是multiply，里面有两个参数
     return num1 * num2  # 返回num1乘以num2的乘积
print(multiply(2, 4))   # 调用multiply函数，num1的值是2，num2的值是4，打印出multiply的返回值是8


def permit(age):   # 定义一个函数是permit，里面有一个参数是age
      if age >= 18:   # 如果age大于等于18
             print("准许进入")   # 打印准许进入
             return True     # 返回True，以下代码不执行
      else :           # 如果age小于18
             print("禁止进入")   # 打印禁止进入
             return False     # 返回False，以下代码不执行
permit(18)   # 调用函数permit，age是18
permit(17) # 调用函数permit，age是17
permit(29) # 调用函数permit，age是29

      上面我们定义了一个只允许成年人进入的函数，如果年龄大于等于18岁，返回True，表示允许通过；如 果小于18岁则不允许。虽然有两个return语句，但只返回一个结果，要么返回True要么返回False。注 意在return语句执行完后，函数就会结束执行，在它之后的任何语句都不会再执行，所以上例中 的“end”无论怎么样都不会被打印。 如果一个函数内没有任何return语句，那它的返回值就是None。

匿名函数

       有时候我们临时需要一个函数，且它的逻辑比较简单，这时候就可以定义匿名函数。

lambda n: n * n

       lambda是Python中的关键字，它的作用就是用来定义匿名函数，匿名函数的函数体一般只有一行代 码，省略了函数名和返回值语句。

revenue = [('1月',5610000),('2月',4850000),('3月',622000)()]
key = lambda x: x[1]     # 定义一个匿名函数key=lambda x，取x得小标是2的值 
for r in revenue:
     print(key(r))   #打印key里面的每一项

面向对象

       面向过程：根据业务逻辑从上到下写代码。

       面向对象：将变量与函数、属性绑定到一起，分类进行封装，每个程序只要负责分配给自己的功 能，这样能够更快速的开发程序，减少了重复代码。

       那什么是对象呢 ？我们可以理解为实际存在的实物，比如一个用户、一台ATM机、一幢建筑，亦或者是 软件业务流程中产生的虚拟概念，比如订单、购物车、用户账户。我们发现，不管是实体还是虚拟产 物，它们都是有一些共同点，都是名词，有自己的行为，有自己的属性。

类和实例

类：定义对象的时候用到的：class 首字母大写
       类是用来创建对象的模板，对象是类的实例

class Dog:     #创建一个类是Dog
         pass
dog = Dog()
dog1, dog2 = Dog(), Dog()   #根据这个类可以创建N个dog对象
print(dog)

通过内置的type函数，可以查看任何对象的类。如果我们不知道一个对象是不是某种类型，就可以用type判断。

type(1)
type('abc')
type([])

isinstance判断是否是实例，判断类和对象的关系
 

print（isinstance(dog, Dog)） #第一个参数是对象dog，第二个参数是需要判断的类

对象的属性与方法

       类的每一个方法的第一个参数是 self ，但在调用的时候却不需要传参数给它。它是 类方法和普通函数的区别，这个self代表的是实例自身，意思是“我的”，现在我们来创建Dog的实例

class Dog:
def __init__(self):
    self.breed = None
    self.color = None
    self.size = None

def eat(self):
    print("I like bones")

def run(self):
    print("I'll catch you.")

def bark(self):
    print('Wang! Wang!')

dog = Dog()
dog.eat()
dog.run()
dog.bark()
print('一只%s型%s色的%s' % (dog.size, dog.color, dog.breed))

# 调用不同的方法能打印出不同的内容，体现了不同的行为。但是最后一句话打印出来的内容却是None，因为我们还没有设置相应的属性。

一切皆对象

       我们使用的数字、字符串、函数甚至类本身，都是对象。所有的对象都可以 用type函数来判断它的类型，同时可以用dir函数来查看它的属性和方法。

"""
会显示出dog对象的所有属性和方法，包括刚刚定义的那几个方法和属性。对于对象，也可以使用help
函数查看它的帮助文档。
"""
dir(dog)

help(sum)

help(print)

模块和包管理

       Python中具有丰富的标准库和第三方库，学习并掌握模块、包的概念尤为重要，决定了我们是否能够利 用这些丰富的资源，以及如何妥善组织好我们自己的代码。

# 导入一个math内置模块
import math

# 可以使用math模块里的所有函数了，可以使用dir来看一下都有哪些函数
dir(math)

# 也可以使用from ... import ... 这种语句来具体导入某一个子模块或函数
from math import sqrt

# 这种方式更精确的导入某个函数，使用起来更方便， 但要注意重名的问题。如果说我们的代码本来就有
一个叫sqrt的函数，那我们可以使用 as 关键字来给模块起一个别名
from math import sqrt as squarte

# 要一次性导入多个模块
import sys, os
from math import sqrt, pow

常用内置模块

datetime - 日期时间类型

      datetime模块中包含了几个常用的日期时间类，其中最常用的是datetime和timedelta

from datetime import datetime, timedelta

# 返回当前时间的detetime对象
now = datetime.now()
type(now)

# 查看当前时间的年月日
print(now.year, now month, now.day)

# 查看当前时间戳，精确到时分秒
now.timestamp()

# 返回指定格式的日期字符串
datetime.now().strftime('%Y-%m-%d %H:%M:%S')

# 将指定格式的字符串转化成日期时间对象
datetime.strptime('2022-11-29 10:17:30', '%Y-%m-%d %H:%M:%S')

日期时间常用的代码含义

代码	含义	栗子
%Y	十进制数表示的带世纪的年份	2022
%m	补零后，以十进制数显示的月份	01，02.....12
%d	补零后，以十进制数显示的月份中的一天	01，02...31
%H	补零后的十进制数表示的小时（24小时制）	00，01...23
%M	补零后以十进制数显示的分钟	00，01...59
%S	补零后以十进制数显示的秒	00，01...59

time时间的访问和转换

还有一个常用的时间模块是time,个人使用最多是用来调试脚本，比如自动化测试中需要找到一个元素，先让程序睡一会

import time

# 返回当前时间戳
time.time()

# 返回房前时间的格式化字符串
time.strftime('%Y-%m-%d %H:%M:%S')

# 用于脚本调试休眠的time.sleep,休眠3秒
time.sleep(3)

random-生成随机数

       random模块会根据当前的系统时间作为随机数种子，所以可以保证生成的随机数不会重复。

# 生成一个随机浮点数，范围[0.0, 1.0)
random.random()

# 生成1到100之间的随机整数，包括1和100
random.randint(1, 100)

# 从序列中随机抽出一个元素
random.choice(['a', 'b', 'c', 'd', 'e', 'f', 'g'])

# 从序列中随机抽出k个元素,注意抽出来的元素可能会重复
random.choices(['a', 'b', 'c', 'd', 'e', 'f', 'g'], k=2)

# 跟choices函数类似，但它是不重复的随机抽样
random.sample(['a', 'b', 'c', 'd', 'e', 'f', 'g'])

# 将一个序列随机打乱，注意这个序列不能是只读的
lst = ['a', 'b', 'c', 'd', 'e', 'f', 'g']
random.shuffle(lst)

os - 操作系统接口

      os模块主要用于使用与操作系统相关的功能的便捷式途径。

# 获取当前的工作目录
print(os.getcwd())

# 创建目录
os.mkdir(os.getcwd() + '/test')  # 只能创建一层目录
os.makedirs(os.getcwd() + '/test2'/123)  # 创建多层目录
os.listdir(os.getcwd())  # 列出当前工作目录下的内容
os.listdir('/')  #列出根目录下的内容

os.path.abspath('./')  #获取当前目录的绝对路径
os.path.abspath('..')  #获取父级目录的绝对路径（当前目录的上一级目录）

# 相对路径：./text.txt ../test/abc.py
# 绝对路径： c:\user\
# 目录分隔符： Windows：\ Linux和Mac：/
print(os.path.abspath(__file__))  # 获取当前文件的绝对路径
# 判断文件是否存在
os.path.isfile(os.path.abspath(__file__))    # 判断某路径是不是常规的文件,返回True或者False
# 输出当前系统下的目录分割符
print(os.sep)
# 拼接多个路径目录
os.path.join(os.getcwd(), 'def','123') # 拼接当前目录\def\123

# 返回当前文件所在的绝对路径
os.path.dirname(os.path.abspath(__file__))
# 返回当前文件的文件名（或者目录）
os.path.basename(os.path.abspath(__file__))

sys - 系统相关参数及函数

       sys.path ，它返回的是一个列表，包含了若干个路径，它表示的是Python查找包的路径顺 序，第一个是一个空字符串，它表示当前目录。之所以我们使用import 语句可以导入模块，靠的就是它。

sys.argv 表示启动的时候传递给Python脚本的命令行参数。

import sys
if __name__ == '__main__':
print("Hello", end=' ')
if len(sys.argv) > 1:
print(' '.join(sys.argv[1:]))

# sys.argv是个列表
type(sys.argv)
print(sys.argv)