Python笔记1

编程基础课程：

什么是python？

简单的编程语言python
python环境搭建---：开发环境 vscode，sublime，pycharm
                                运行环境  cpython解释器
python -V测试运行环境

python怎么写代码

1，在终端写代码--代码无法保存
2，写在python文件中 .py      
       通过python python文件名
注释：单行注释   #
          多行注释  '''  ''' ;   """  """
变量：在程序运行的时候，可以发送变化的量
常量：在程序运行的时候，不可以发送变化的量
变量声明
java：变量类型  变量名=变量值
         int age=10
python：变量名=变量值
a,b=1,2

(标识符）
变量名命名规范：

                          1、使用大小写字母，数字，下划线
                          2、不能以数字为开头
                          3、不能使用关键字和保留字
                          4、不能使用python全局中已经用过的
                          5、建议标识符名称具有意义
                          6、建议使用_或者小驼峰命名法
                                find_usergroup_by_username
                                  findUsergroupBYUsername
7、特殊：类：大驼峰命名FindUsergroupBYUsername
                     python中没有常量的关键字的，变量名称全部大写用来表示常量
                      abc=11     ABC=22   PI=3.14
dir()：显示对象中存在的方法

python的数据类型：

基本数据类型

数字类型===》整形（int）、浮点型（float）、复数（a+bi）
布尔类型===》true  false   判断条件是否成立的（bool)
字符串类型===》""       ''       ''' '''    """ """ str  三引可以换行   例如 '12'
"i'am ok"    I'm ok
'i\'am ok':通过转义符表面'
\n：换行符
input（"提示语"）
ord（）：获取字符的整数表示
chr（）：把编码转换为对应的字符
type（）：用来检测变量的数据类型的

复合数据类型===》所有的对象

字典、列表、元组、集合
数据类型转换：自动类型转换：整形  浮点型  布尔类型：非0为真，0为假
                       强制类型转换：
                                            int()\float()\str()
num1+num2=num3
print(a+"+"+b+"="+str(c))===>a+b=c
清屏：import os
          os.system（"command")

常见的运算符：

算数运算符： 

+ - * /  //(整除） %(取余） **(平方）

关系运算符： 

 >  <  >=  <=  ==  !=(<>)

逻辑运算符：

 and(两真才真，一假则假） or(一真则真，两假才假） not

所属运算符  

in    not in

is运算符：

is判断内存地址是否相同    ==判断值是否相同

赋值运算符：

  = 、+=、-=、*=、/=、//=、%=、**=
 python中不存在自增自减
（//：整除；/：一定得到小数）

三目运算符：

变量=值1 if条件 else 值2
 age=int(input("请输入你的年龄"))
n="成年了"if age > 18 else "未成年"
 print(n)

位运算符：

计算机底层的运算规则
 & |  ^ ~ <<  >>

|：把两边的二进制各位进行或运算（两假才假）（两0才0，一1则1）
例如：2|3：
          0000 0010
          0000 0011
          -----------
          0000 0011  3
10|11
0000 1010
0000 1011
-----------
0000 1011

&：一假则假（一0则0）

10&11
0000 1010
0000 1011
-----------
0000 1010

^:相反为真（相反为1）

10^11
0000 1010
0000 1011
-----------
0000 0001

~:按位取反 连带符号位

~10
0000 1010

1111 0101（补码）
1111 0100
1000 1011（-11）     ~10==》-11

<<  所有二进制朝左移n位  12<<1(n)  增长2的n次方倍
>>  所有二进制朝右移n位   12>>1     无符号位右移

电脑？数学模型  记录数据===》处理数据
半导体材料===》从一边到另外一边是通电的，反向不通电
一个二极管，对应一个二进制的数（0/1） ---1bit
   1 byte=8个二极管 (8bit)------0~255   256
 
1-----48   00110000
B-----66   01000010
1100001000010

1k   1024B
1M  1024k
1G   1024M

10+11
基于byte
00001010
00001011

负数：最高位作为符号位  0表示正  1表示负
-128~127   256

为了解决负数运算的问题，提出了三个概念：
原码  十进制对应的二进制    1000 0011（-3）
反码  符号位不变，其余位取反  1111 1100
补码  反码+1                        1111 1101

2+ -3
0000 0010（2的原码）
1111 1101（3的补码）
-----------
1111 1111 补码
1111 1110 反码
1000 0001 原码（-1）

3.21
程序控制流程

解决语句与语句之间运行的顺序的问题

顺序：

代码整体的执行顺序  从上到下 从左到右

 

选择：

不同条件下，执行不同的代码
   

      单分支：

          if条件：
           #条件成立时执行的代码
（缩进强调的是在同一个块内缩进量一致    tab键和空格键不要进行混用）

 

     双分支：

          if条件：
              #条件成立时执行的代码
          else：
               #条件不成立时执行的代码（pass关键字保证语法的完整性）

  多分支：

        if  条件1：
              条件1成立时执行的代码
        elif 条件2：
               条件2成立时执行的代码
         .......
        elif条件n：
                条件n成立时执行的代码
        else:
             以上条件都不成立时执行的代码

循环：

     while 条件：
          循环体
3.22

while 条件：

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

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

for 临时变量 in 容器：

3.24

index = .....
while 条件：
       循环体
       #判断的index数值改变

for 临时变量 in 容器：
      代码
range（num1）：[0,num1)之内所有的整数
range(num1,num2,step):
range(10,0,-1)

容器

数据结构：

线性表：

数组：

类型一致的，大小固定，连续的内存结构
（python里无数组）

链表：

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

栈：

先进后出

队列：

先进先出

一，python的内置容器：

1.list列表：

   底层使用的是双向列表--线性表--有序的
  （1）如何定义
                 变量名=[ ]
         b=[1,2,3,4,"gouxin",True]  列表里边可以存储不同的数据类型

         list([1,2,3,4])  list("zhangsan")  ---强制转换成列表
    （2）获取列表的长度  len()
      (3)获取每一个元素

（下标：从0开始，从左向右;从右向左，下标从-1开始 -2 -3
                            -1
         [1,2,3,4,"zhangsan"]
          0,1,2,3,4                 ）
aa[len(aa)-1]

修改数据：列表名[列表下标]="新的数据"
aa[下标]="......."
”怎么添加数据，删除数据？“

     （4）遍历列表
            for
            while
列表的常见方法：
['__add__', '__class__', '__contains__', '__delattr__', '__delitem__', '__dir__',
 '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', 
'__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():向列表的尾部追加元素
insert(下标，添加的元素)
列表1.extend(列表2)：合并列表的  列表2的数据合并给列表1

删除：
remove（元素）---列表名.remove（”元素“）
pop():通过下标删除元素，不给参数时，删除的是最后一位 -1。会返回删除的元素
clear():清空列表里的数据

查：
index(元素)获取匹配到的第一个元素的索引下标
index(元素，start)从start下标开始查找

count(元素)：计数

copy（）：拷贝 浅拷贝
>>> a = [1,2,3,4]
>>> b = a.copy()
>>> b
[1, 2, 3, 4]

reverse（）：反转
>>> a.reverse()
>>> a
[4, 3, 2, 1]

sort（）
>>> a=[3,6,1]
>>> a.sort()
>>> a
[1, 3, 6]
sort（reverse=True）   sort（reverse=False)
（False从小到大排序，True从大到小排序）

2.set（集合）：

底层基于哈希表实现的：不能重复，无序
set（）
集合无法进行访问的---无序的

len（）
集合怎么遍历：
for

集合常见的方法：
['__and__', '__class__', '__contains__', '__delattr__', '__dir__', '__doc__', '__eq__',
 '__format__', '__ge__', '__getattribute__', '__gt__', '__hash__', '__iand__', '__init__', 
'__init_subclass__', '__ior__', '__isub__', '__iter__', '__ixor__', '__le__', '__len__', '__lt__',
 '__ne__', '__new__', '__or__', '__rand__', '__reduce__', '__reduce_ex__', '__repr__', '__ror__',
 '__rsub__', '__rxor__', '__setattr__', '__sizeof__', '__str__', '__sub__', '__subclasshook__', 
'__xor__', '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（）：交集
difference（）：差集
union（）：并集

3.元组tuple

不可变数据类型。元组是有序的（元组声明后不能再追加数据）
（1，2，3，4）
tuple（）

>>> tu1=()
>>> type(tu1)
<class 'tuple'>
>>> tu2=("zhangsan",2,1,3)
>>> tu2
('zhangsan', 2, 1, 3)
>>> tu2[2]
1

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

len（元组名）

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

元组中元素存在可变数据类型，那么更改可变数据中的元素不会报错
>>> tu1=(1,2,3,[5,6,7])
>>> tu1[3][1]="zhangsan"
>>> tu1
(1, 2, 3, [5, 'zhangsan', 7])

4.字典

{}
dict（）
dict={”uname“：”zhangsan“，”age“：21，1：21，”sex“：”nan”}

查找数据：
字典名["键名"]
dict1["school"]="huazhu"存在则覆盖，不存在则进行添加
len（）
key：value
get（key，默认不存在时则返回）：通过key获取值的
keys（）：获取所有的键
values（）：获取所有的值

setdefault（）：添加键值对
del 要移除的项，可以删除任何的变量
dict1.fromkeys（（1，2，3，4））：创建key值为1，2，3，4的字典，键值为none

删除：
pop（）：通过key删除键值对

items（）：返回键值对
update（）

遍历字典
for

二，排序

      1.冒泡

                特点：相邻的两两进行比较
       arr=[1,21,33,42,2,54]
   [21，33，42，2，54，1]
      [33，42，21，54，2，1]
      [42，33，54，21，2，1]
      [42，54，33，21，2，1]
      [54，42，33，21，2，1]
   
   for i in range(0,len(arr)-1):
       for j in range(0,len(arr)-1):
             if arr[j]>=arr[j+1]:
                 arr[j],arr[j+1]=arr[j+1],arr[j]
             else:
                  pass

3.28

一，排序：

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

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

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

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
（i=4执行后的结果[1，3，22，24，36，43]）

二，函数

       函数是什么？一段实现某一特定功能的代码的集合
       本质上实现了代码的高度复用
       函数定义方式：
       def 函数名([形参])：
               一行或者多行的函数体
               [return返回值]
    
       调用函数：函数名加（）
 
大O
时间复杂度:O(1) O(logN) O(n) o(n^2)
ps.计算机中logN若无指定则默认以2为底。

空间复杂度

算法的稳定性