python笔记

变量：在程序运行的时候，可以发生变化的量    -----具有名称的内存空间

常量：在程序运行的时候，不可以发生变化的量

设置变量的方法： 变量名 = 变量值 例：a = 1    a，b = 1，2

设置标识符（变量）规范：1、使用大小写字母、数字、下划线

                        2、不能以数字开头

                        3、不能使用关键字和保留字

                        4、不能使用python全局中已经用过的

         5、建议标识符名称具有意义   age  

         6、建议使用_或者小驼峰命名法

     find_usergroup_by_username

     findUsergroupByUsername

          7、特殊  ：类  ：大驼峰命名 FindUsergroupByUsername

python中没有常亮的关键字的，变量名称全部大写用来表示常量                       

  abc  = 11        ABC=22       PI = 3.14

dir（）：显示对象中存在的方法

ord():获取字符的整数表示

chr():把编码转换为对应的字符

input("提示语")---用于让用户输入变量

type（）：用来检测变量的数据类型的

数据类型：

数字类型---整形（int）、浮点型（float）、复数（a+bi）

布尔类型---Ture False 判断条件是否成立

字符串类型--- str

数据类型转换：自动类型转换： 整型   浮点型   布尔类型：非0为真，0为假

              强制类型转换：int()\float()\str()

常见的运算符:

算数运算符：+  -  *  /   //(整除)  %（取余）  **

关系运算符：>   <  >=  <=  ==   !=(<>)

逻辑运算符：and(两真才真，一假则假)    or（一真则真，两假才假）   not

所属运算符   in     not in

is运算符: is 判断内存地址是否相同   == 判断值是否相同

赋值运算符: = +=   -=   *=  /=  //=  %=  **=

三目运算符:   变量 = 值1 if  条件 else 值2

               age = int(input("请输入你的年龄"))

               n = "成年了" if age > 18 else "未成年"

               print(n)

位运算符：计算机底层的运算规则：把两边的二进制各位进行或运算

|：两假才假.一真则真

2|3：

0000 0010

0000 0011

-------------

0000 0011     3

10|11

0000 1010

0000 1011

------------

0000 1011

&:一假则假

10 &11

0000 1010

0000 1011

------------

0000 1010

^ :相反为真

10 ^ 11

0000 1010

0000 1011

------------

0000 0001

~  按位取反  连带符号位

~10

0000 1010

1111 0101  (补码)

1111 0100

1000 1011

<<   所有二进制位朝左移n位    12<<1    增长2的n次方倍

>>     所有二进制位朝左移n位  12 >>1      无符号位右移

原码   十进制对应的二进制                  1000 0011

反码   符号位不变，其余位取反        1111 1100

补码   反码+1                        1111 1101

单分支：

if    条件:

​        #条件成立时执行的代码(前面有四个空格缩进）

双分支：

if    条件:

​        条件成立时执行的代码

else:

​        条件不成立时执行的代码

多分支：

if   条件1：

​        条件1成立时执行的代码

elif   条件2：

​        条件2成立时执行的代码

……

elif 条件n：

​        条件n成立时执行的代码

else：

​        条件都不成立时执行的代码

循环

while  条件:（当布尔类型为Ture时会一直执行）

​        循环体

else：

        循环正常结束时执行的代码

for循环：主要用于容器的迭代

for 临时变量  in  容器:

    代码

range(num1):[0,num1)之内所有的整数

range(num1,num2):[num1,num2)之间所有的整数（不包括num2）

range(num1,num2,step)（step为步长）  range(10,0,-1)

数据结构：

线性表：  有序的

数组   ：类型一致的，大小固定，连续的内存结构

链表：不一定要内存空间连续，大小不固定

栈   ：先进后出

队列  ： 先进先出

python的内置容器：

list列表

set集合

tuple元祖

dict 字典

list列表：底层使用的是双向链表  线性表    有序的

1、定义：

（1）变量名 = []    b = [1,2,3,4,"gouxin",True]    列表里边可以存储不同的数据类型

（2）list([1,2,3,4])       list("zhangsan")

2、获取列表的长度    len()

3、获取每一个元素        列表名[列表下标]（下标：从左向右---从0开始1，2 …… 从右向左---下标从-1开始-2，-3……）

修改数据：列表名[列表下标] = 新的数据

4、遍历列表

- ​    for

- while

列表的常见方法：

~~~

['add', 'class', 'class_getitem', 'contains', 'delattr', 'delitem', 'dir', 'doc', 'eq', 'format', 'ge', 'getattribute', 'getitem', 'getstate', 'gt', 'hash', 'iadd', 'imul', 'init', 'init_subclass', 'iter', 'le', 'len', 'lt', 'mul', 'ne', 'new', 'reduce', 'reduce_ex', 'repr', 'reversed', 'rmul', 'setattr', 'setitem', 'sizeof', 'str', 'subclasshook', 'append', 'clear', 'copy', 'count', 'extend', 'index', 'insert', 'pop', 'remove', 'reverse', 'sort']

~~~

'append', 'clear', 'copy', 'count', 'extend', 'index', 'insert', 'pop', 'remove', 'reverse', 'sort'

增加数据：

append()：向列表的尾部追加元素

>>> list1.append("zhangsan")

insert(下标,添加的元素)

>>> list1.insert(1,"huazhu")

['wangmazi', 'huazhu', 'zhangsan', 'lisi']

列表1.extend(列表2):合并列表2的数据合并给列表1

>>> list2 = [1,2,3]

>>> list1.extend(list2)

>>> list1

['wangmazi', 'huazhu', 'zhangsan', 'lisi', 1, 2, 3]

删除数据：

remove(元素)

pop()：通过下标删除元素  不给参数时，删除的是最后一位-1 会返回删除的元素

>>> aa

['z', 'n', 'g', 's']

>>> aa.pop()

's'

>>> aa.pop(1)

'n'

>>> aa

['z', 'g']

>>> n =aa.pop()

>>> n

clear()：清空列表里的数据

查找数据：

index(元素)获取匹配到的第一个元素的索引下标

index(元素,start)  从start下标开始查找

>>> aa = [1,2,3,4,3,2,1]

>>> aa

[1, 2, 3, 4, 3, 2, 1]

>>> aa.index(2)

1

>>> aa.index(2,3)

5

count(元素):计数

copy()：拷贝  浅拷贝    

>>> a = [1,2,3,4]

>>> c = a.copy()

>>> c

[1, 2, 3, 4]

reverse()：反转

sort(reverse=True)

set(集合)：底层基于哈希表实现的：不能重复，无序

命名方法：set()

集合无法进行访问的----无序的

遍历：

>>> for i in set:

...     print(i)

集合常见的方法：

'add', 'clear', 'copy', 'difference', 'difference_update', 'discard', 'intersection', 'intersection_update', 'isdisjoint', 'issubset', 'issuperset', 'pop', 'remove', 'symmetric_difference', 'symmetric_difference_update', 'union', 'update'

add(元素)

pop():任意一个元素被移除

remove(元素)

discard(元素)    区别：要移除的元素不存在时，discard（）不会进行报错

intersection()：交集

>>> set1.union(set2)    #并集

{1, 4, 5, 7}

>>> set1.difference(set2)   #差集

{5}

~~~

元组tuple：不可变数据类型，有序的

设置元组方法：

tuple()

访问：元组名[元祖下标]

>>> tu3.count(3)

1

>>> tu3.index(3)

2

~~~

ps：如果一个元组只有一条数据，那么需要在这条数据后面加上逗号

>>> tu4 = ("zhangsan",)

>>> type(tu4)

<class 'tuple'>

元组中元素存在可变数据类型，那么更改可变数据类型中的元素不会报错

tu = (1, 2, 3, 4, ["zhangsan", 1, 2, 3])

tu[-1][0] = "woshigenggaiguode"

字典

设置字典方法：

dict1 = {"uname":"zhangsan","age":21,1:21,"sex":"nan"}

查找数据：

字典名["键名"]

dict1["school"] = "huazhu"    存在，则进行覆盖，不存在，则进行添加

key:value

 'clear', 'copy', 'fromkeys', 'get', 'items', 'keys', 'pop', 'popitem', 'setdefault', 'update', 'values'

get(key,默认不存在时返回)：通过key获取值的

keys():获取所有的键

values（）：获取所有的值

setdefault()：添加键值对

del   要移除的项    可以删除任何的变量

dict1.fromkeys((1,2,3,4))：创建key值为1,2,3,4的字典，键值为none

删除：

pop():通过key删除键值对

items()：返回键值对

update()

遍历：

for

排序：为数据进行排序，后期配合其他算法，实现数据的快速查找

大O

时间复杂度：O(1)  O(logN)  O(n)  o(n^2)

空间复杂度

算法的稳定性

冒泡排序：相邻的两两进行比较 

选择排序:假设一位最小值，

插入排序：假设首位是有序的，保证第i个之前都是有序的

[22,1,3,43,24,36]   i =0

[1,22,3,43,24,36]   i= 1

[1,3,22,43,24,36]   i = 2

[1,3,22,43,24,36]   i =3

[1,3,22,24,43,36]  i=4

[1,3,22,24,36,43]

~~~

arr1 = [22, 1, 3, 43, 24, 36]

for i in range(0, len(arr1)-1):

    for j in range(i+1, 0, -1):

        if arr1[j] < arr1[j-1]:

            arr1[j], arr1[j-1] = arr1[j-1], arr1[j]

函数：实现代码的高度复用

函数定义方式：

def  函数名([形参]):

​        一行或者多行的函数体

​        [return 返回值]（需要返回值是设计返回值）

本地变量与全局变量

本地变量(局部变量）:声明在函数内部的变量

全局变量：全局变量在任何位置都能够被读取

ps：默认情况下，全局变量不允许被函数内部进行更改，局部变量只能在函数内部进行访问。外部要进行访问，通过return返回出去

函数调用的本质：程序启动的瞬间，会生成至少一个执行栈，函数是在堆中存放的，每当函数被调用时，会进行压栈，调用结束之后，会立刻进行弹栈

值传递和引用传递

值传递传递的是值，引用传递传递的是内存地址

参数：

默认值参数：大多情况下，该参数值不需要改变，书写位置一般在正常参数的后面。方便用户调用函数

ps：默认值参数指向不可变数据

可变参数   *参数名

*args

如果说要传进去的参数是元组或者列表，只需要在元组或者列表前面添加*，就会吧元祖或列表作为可变参数穿进去

关键字参数（命名参数）：

**kwargs

匿名函数  lambda表达式

lambda [参数]: 函数

不需要return

字符串：是一种典型的不可变类型

字符串是一个对象

定义：

''

""

a = """   """

b = '''   '''

str()

字符串也存在下标

字符串对象常见的方法：

'capitalize', 'casefold', 'center', 'count', 'encode', 'endswith', 'expandtabs', 'find', 'format', 'format_map', 'index', 'isalnum', 'isalpha', 'isascii', 'isdecimal', 'isdigit', 'isidentifier', 'islower', 'isnumeric', 'isprintable', 'isspace', 'istitle', 'isupper', 'join', 'ljust', 'lower', 'lstrip', 'maketrans', 'partition', 'removeprefix', 'removesuffix', 'replace', 'rfind', 'rindex', 'rjust', 'rpartition', 'rsplit', 'rstrip', 'split', 'splitlines', 'startswith', 'strip', 'swapcase', 'title', 'translate', 'upper', 'zfill'

capitalize():首字母大写   返回新的字符串

center() :居中对齐

 ~~~

 >>> s.center(50,"*")

 '******************huazhu huazhu*******************'

count()  :同级元素的个数

endswith():判断字符串是否以什么结尾.返回的是布尔值

 startswith():是否以……开始

find(查找的字符，【检索开始的下标，检索结束的下标】):从左到右检索某个字符或字符串，找到第一个满足的字符或字符串，并且返回下标

find()如果未检索到，最终会返回-1

index()

未检索到，直接报错

rfind():从右边向左边进行检索

rindex

format()：格式化字符串的

>>> print("姓名是{}".format(num))

姓名是2

join():按照特定的规则进行字符串的拼接

split()按照特定的字符串进行分割，最终返回的是一个列表

>>> s.split(" ")

['huazhu', 'huazhu']

upper():转大写

lower():转小写

strip():清除字符串两边的空格的

lstrip()：清除左边的空格

rstrip()清除右边的空格

title()  标题格式（每个单词的首字母大写）

replace(old，new)返回一个新的字符串

encode():转换编码格式，将字符串转换为字节

decode():将字节转换为对应的编码

切片：拿到多个有序的元素

可以对标range

[start:end  : step]:

start:不写的情况下，默认从下标为0的地方开始切片     

取左不取右

end:不写的情况下，默认直接切片到所有元素结束

step:不写的情况下默认为1

切片切不到时，只会无返回，不会进行报错

print(str1[1:6:-1])：start = 1  end = 6   表明切片方向是从左向右，但是，step采用-1，是表明从右向左切