python基础

编程基础

Python基础课：编程基础课程、python基础课程、面向对象编程、python高级知识
 
编程基础课程：
什么是python？
简单的编程语言-->python
 
怎么用？
python环境搭建：
开发环境：vscode、sublime、pycharm……
运行环境：cpython解释器
 
Python -V：测试运行环境
 
怎么写代码？
1.在终端写代码-->代码无法保存
2.写在python文件中（.py结尾的文件）
  python python文件
 
注释：
单行注释 #
多行注释 （'''  '''）（"""  """）
 
变量：在程序运行的时候，可以发生变化的量——具有名称的内存空间
常量：在程序运行的时候，不可以发生变化的量
 
java：变量类型 变量名=变量值
          int age=10
 
python：变量名=变量值
               age=10
               a,b=1,2
 
变量名（标识符）命名规范：
（1）使用大小写字母、数字、下划线
（2）不能以数字开头
（3）不能使用关键字和保留字
（4）不能使用python全局中已经用过的
（5）建议标识符名称具有意义
（6）建议使用_或者小驼峰命名法
        find_usrgroup_by_username
（7）特殊：类：大驼峰命名
        FindUsergroupByUsername
python中没有常量的关键字的，变量名称全部大写用来表示常量
abc=11    ABC=22    PI=3.14
 
dir()：显示对象中存在的方法
 
python的数据类型：
基本数据类型
数字类型-->整型（int）、浮点型（float）、复数（a+bi）
布尔类型-->true  false  判断条件是否成立（bool）
字符串类型-->（""）（''）（''' '''）（""" """）str  三引号可以换行
'i\'am ok'：通过转义符表明
 
\n：换行符
 
ord()：获取字符发整数表示
chr()：把编码转换为对应的字符
 
input("提示语")
type()：用来检测变量的数据类型
 
复合数据类型-->所有的对象
字典、列表、元组、集合
 
数据类型转换：
自动类型转换：整型、浮点型、布尔类型（非0为真，0为假）
强制类型转换：int()\float()\str()
字符串只能和字符串进行拼接
 
清屏：
import os
os.system("command")
 
常见的运算符：
（1）算术运算符：+ - * /  //(整除)  %(取余)  **(次方)
（2）关系运算符：>  <  >=  <=  ==  !=(<>)
（3）逻辑运算符：and(两真才真，一假则假)  or(一真则真，两假才假)  not 
（4）所属运算符：in    not in
（5）is运算符：is 判断内存地址是否相同，== 判断值是否相同
（6）赋值运算符：=    +=    -=    *=    /=    //=    %=    **=
                          python中不存在自增自减
                          a += 1   a = a+1 
（7）三目运算符：变量 = 值1 if 条件 else 值2
age = int(input("请输入你的年龄"))
n = "成年了" if age > 18 else "未成年"
print(n)
（8）位运算符：计算机底层的运算规则
        |     &    ^     ~     <<     >>
 
电脑？数学模型  记录数据-->处理数据
半导体材料-->从一边到另一边是通电的，反向不通电
一个二极管，对应一个二进制的数（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
-------------
00010101--21
 
负数：-3   最高位作为符号位   0表示正，1表示负
-128~127   256位
 
Byte
2+(-3)
0000 0010   2
1000 0011   -3
----------
1000 0101   -5-->为了解决负数运算，提出了三个概念
 
原码    十进制对应的二进制             1000 0011
反码    符号位不变，其余位取反      1111 1100
补码    反码+1                                  1111 1101
 
2+(-3)
0000 0010
1111 1101
--------------
1111 1111  补码
1111 1110  反码
1000 0001  原码    -1
 
|：把两边的二进制各位进行或运算（两假才假）两0才0，一1则1
2 | 3：
0000 0010
0000 0011
--------------
0000 0011   3
 
10 | 11
0000 1010
0000 1011
--------------
0000 1011    11
 
&：一假则假（一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（原码）
 
<<：所有二进制位朝左移n位
12<<1（所有二进制朝左移1位）增长2的n次方位
 
>>：所有二进制位朝右移n位
12>>1（所有二进制朝右移1位）无符号位右移
 
 
eval：将后面的值一一对应地赋值给前面的变量
>>>evel("1,2")
(1, 2)
>>>a, b = eval("1,2")
>>>a
1
>>>b
2

程序控制流程：

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

Ctrl+/：快速注释
 
顺序：代码整体的执行顺序  从上到下  从左到右
换行用enter
print("666")
print("777")
同一行用分号;
print("666");print("777")
 
 
选择：不同条件下，执行不同的代码
单分支：
if条件：
#条件成立时执行的代码
 
age = int(input("请输入您的年龄："))
if age > 18:
    print("你成年了，进去玩吧")
 
双分支：
if条件：
       #条件成立时执行的代码
else:
       #条件不成立时执行的代码
 
 
index = 11
if index > 11:
    print("oooo")
else:
    pass
#pass关键字保证语法的完整性
 
嵌套：
age = int(input("请输入您的年龄："))
if age > 18:
    print("你成年了，进去玩吧")
else:
    if age > 16:
        print("满16")
    else:
        print("未满16周岁")
 
# 缩进强调的是在同一个块内缩进量一致
# tab键和空格键不要进行混用
 
 
多分支：
if  条件1：
条件1成立时执行的代码
elif 条件2：
条件1成立时执行的代码
……
elif 条件n：
条件n成立时执行的代码
else:
条件都不成立时执行的代码
（else可写可不写）

#双分支
month = int(input("请输入一个月份："))
if month > 12 or month <1:
    print("出错啦~~~")
else:
    if 1<=month<=3:
        print("春天")
    else:
        if 4<=month<=6:
            print("夏天")
        else:
            if 7<=month<=9:
                print("秋天")
            else:
                print("冬天")
 
#多分支
month = int(input("请输入一个月份："))
if month > 12 or month <1:
    print("出错啦~~~")
elif 1<=month<=3:
    print("春天")
elif 4<=month<=6:
    print("夏天")
elif 7<=month<=9:
    print("秋天")
else:
    print("冬天")
 
#平闰年（demo21）
year = int(input("请输入年份："))
if year%4==0 and year%100!=0:
    print("闰年")
elif year%400==0:
    print("闰年")
else:
    print("平年")
 
#猜拳（demo28）
# 0-剪刀  1-石头  2-布
import random
computer = random.randint(0,2)  #[0,2]
my = int(input("请输入你所出的拳："))
if computer == my:
    print("平局")
elif(computer == 0 and my == 1)or(computer == 1 and my == 2)or(computer == 2 and my == 0):
    print("你赢了")
else:
    print("你输了")

循环
while条件：
循环体
else：
循环正常结束时执行的代码
 
#打印100个hello,python
index = 1
while index <= 10:
    print("hello,python")
    index += 1
 
#打印100以内的偶数（自然数）
i = 0
while 0 <= i <= 100:
    if i % 2 == 0:
        print(i)
    i += 1
 
#打印100以内所有偶数的和
i = 0
o_sum = 0
j_sum = 0
while 0 <= i <=100:
    if i & 1 == 0:
        o_sum += i
    else:
        j_sum += i
    i += 1
print(j_sum)
print(o_sum)
 
#打印三层****
a = index = int(input("请输入想打印的层数："))
index = 1
while index <= a:
    print("****",end=" ")
    index += 1
#print自带换行，若不换行，在后面加,end=" "
 
 
'''
*
**
***
****
'''
a = int(input("请输入要打印的层数："))
index = 1
while index <= a:
   j = 1
   while j <= index:
       print("*",end="")
       j += 1
   print()
   index += 1
#print()自动换行
 
 
for循环：主要用于容器的迭代
for 临时变量 in 容器：
代码
 
25、27、54、49、43
 
 
index = 1（索引）
while 条件：
循环体
#判断的index数值改变
 
 
for 临时变量 in 容器:
代码
 
range(num1):[0,num1)之内所有的整数
range(num1,num2):[num1,num2)之间所有的整数
range(num1,num2，step):
range(10,0,-1)

数据结构：

自己构造数据存储容器
 
线性表：有序的
数组：类型一致的，大小固定，连续的内存结构（查找速度快，删除、添加麻烦）
链表：
双向链表：不一定要内存空间连续，大小不固定（可添加数据），头指针（存储下一个数据的尾指针）、尾指针（存储下一个数据的头指针）造成内存浪费
单向链表：只有一个尾指针（指向下一个数据）
栈：先进后出
队列：先进先出

python的内置容器：

list列表
set集合
tuple元祖
dict字典
 

list列表

底层使用的是双向链表  线性表  有序的
 
1.如何定义
(1)变量名 = [ ]
b = [1,2,3,4,"haha",True]  列表里边可以存储不同的数据类型
(2)list([1,2,3,4])  list("zhangsan")
 
2.获取列表的长度  len()
 
3.获取每一个元素   列表名[列表下标]
 
下标：从0开始，从左到右；从右到左，下标从-1开始
[1,2,3,4,"zhangsan"]
0,1,2,3,4
 
 aa[len(aa)-1]
 
修改数据：列表名[列表下标]=新的数据
 
“怎么添加数据、删除数据？”
 
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 = [ ]
>>> list
<class 'list'>
>>> list1
[ ]
>>> list.append("zhangsan")
 
insert(下标，添加的元素)
>>> list1.insert(1,"huazhu")
>>> list1
['wangmazi', 'huazhu', 'zhangsan', 'lisi']
 
列表1extend(列表2)；合并列表的（列表2的数据合并给列表1）
>>> list2=[1,2,3]
>>> list1.extend(list2)
>>> list1
['wangmazi', 'huazhu', 'zhangsan', 'lisi', 1, 2, 3]
 
 
删除：
remove(元素)
>>> aa
['z','zhangsan','n','g','s']
>>> aa.remove("zhangsan")
>>> aa
['z','n','g','s']
 
pop()通过下标删除元素  不给参数时，删除的是最后一位 -1  会返回删除的元素
>>> aa
['z','n','g','s']
>>> aa.pop()
's'
>>> n=aa.pop(1)
'n'
>>> aa
['z','g']
>>> n=aa.pop()
>>> n
'g'
>>> aa
['z']

chear()：清空列表里的数据
>>> aa.append("zhangsan")
>>> aa
['z','zhangsan']
>>> aa.clear()
>>> aa
[ ]
 
查：
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()：计数
>>> aa=[1,2,3,4,3,2,1]
>>> aa
[1, 2, 3, 4, 3, 2, 1]
>>> aa.count(2)
2
>>> aa.count(4)
1
 
copy()：拷贝  浅拷贝
>>> a=[1,2,3,4]
>>> a
[1, 2, 3, 4]
>>> c=a.copy()
>>> c
[1, 2, 3, 4]
>>> a.append("zhangsan")
>>> a
[1, 2, 3, 4, 'zhangsan']
>>> c
[1, 2, 3, 4]
 
reverse()：反转
>>> a=[1,2,3,4,'zhangsan']
>>> a.reverse()
>>> a
['zhangsan', 4, 3, 2, 1]
 
sort()：默认情况下为sort(reverse=False) 从小到大；从大到小为sort(reverse=True)
>>> a=[2,1,3]
>>> a.sort()
>>> a
[1, 2, 3]
>>> a.sort(reverse=False)
>>> a
[1, 2, 3]
>>> a.sort(reverse=True)
>>> a
[3, 2, 1]

set(集合)

底层基于哈希表实现的：不能重复，无序
set()
 
{1，2，3，4}
 
集合无法进行访问的——无序的
 
len()：显示数据的个数（通用）
 
集合怎么遍历：
for
>>> set2
{1, 2, 3, 4, 'zhangsan'}
>>> for i in set2:
...     print(i)
...
1
2
3
4
zhangsan
 
 
集合常见的方法：
'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
{1, 4, 5}
>>> set2={7,4,1}
>>> set1.intersection(set2)    交集
{1, 4}
>>> set1.union(set2)     并集
{1, 4, 5, 7}
>>> set1.difference(set2)     差集
{5}

tuple元组

不可变数据类型  有序的
(1,2,3,4)
tuple
访问：元组名[元组下标]
 
len(元组名)
 
>>> tu3.count(3)
1
>>> tu3.index(3)
2
 
如果一个元组只有一条数据，那么需要在这条数据后面加上逗号
>>> tu4=("zhangsan",)
>>> type(tu4)
<class 'tuple'>
元组中存在可变数据类型，那么更改可变数据类型中的元素不会报错
tu = (1,2,3,4,["zhangsan",1,2,3])
tu[-1][0] = "我是更改过的"
print(tu)

dict字典

{}
dict()
 
>>> dict1={"uname":"zhangsan","age":21,1:21,"sex":"nan"}
 
查找数据：
字典名["键名"]
 
>>> dict1["school"]="huazhu"  存在，则进行覆盖；不存在，则进行添加
 
len()
 
kev: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)
 
空间复杂度
 
算法的稳定性

冒泡排序：

相邻的两两进行比较
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]
 
从大到小排序：
arr = [1,21,33,42,2,54]
for i in range(0,len(arr)-1):
    for j in range(0,len(arr)-1-i):
        if arr[j] <= arr[j+1]:
            arr[j],arr[j+1] = arr[j+1],arr[j]
        else:
            pass
print(arr)

选择排序：

假设一位最小值
每一次找到最小值
[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]
 
 
arr1 = [2,1,32,23,42,12]
for i in range(0,len(arr1)-1):
    min = i
    for j in range(i+1,len(arr1)):
        if arr1[j] < arr1[min]:
            min = j
    if min != i:
        arr1[i],arr1[min] = arr1[min],arr1[i]
print(arr1)

插入排序：

假设首位是有序的
保证第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] 

函数

函数是什么？
一段实现某一特定功能的代码集合
函数碰见return会立刻进行返回

本质上实现了代码的高度复用
 
函数的定义方式：
def 函数名（[形参]）：
一行或者多行的函数体
[return 返回值]
 
调用函数：函数名()

本地变量（局部变量）和全局变量
本地变量（局部变量）：声明在函数内的变量
 
全局变量：
 
全局变量在任何位置都能够被读取，
 
默认情况下，全局变量不允许被函数内部进行更改
 
 
局部变量只能在函数内部进行访问。
外部要进行访问，通过return返回出去
 
函数调用的本质：
程序启动的瞬间，会生成至少一个执行栈，函数是在堆中存放的，每当函数被调用时，会进行压栈，调用结束之后，会立刻进行弹栈
 
值传递和引用传递
值传递传递的是值，引用传递传递的是内存地址
 
参数：
默认值参数：大多数情况下，该参数值不需要改变，书写位置一般在正常参数后面。方便用户调用函数
 
注意：默认值参数指向不可变数据
 
可变参数：*参数名
 
*args
 
如果说要传进去的参数是元组或者列表，只需要在元组或者列表前面添加*，就会把元组或者列表作为可变参数穿进去
 
关键字参数（命名参数）：
**kwargs
 
 
匿名函数  lambda表达式
lambda[参数]:函数