# Python入门

## 编码格式声明

``` python
#encoding:格式 # utf-8//gbk 
```

## print函数

``` py
print() //输出 字符串（“”） 运行计算不需要“”
如果要实现不换行需要在变量末尾加上 end=""
```

``` python
字符串类型和数值类型连接，需要转换为 字符串类型 //str()
```

``` python
print(a>b)# pring 里面可以做比较，返回 True 或False
```

## open函数

``` python
这是一个创建文件，并且可以配合print加内容的一个函数。open要定义变量接收。
```

``` python
add=open('文件绝对路径'，'a+')# 'a+'的意思为 如果文件不存在就创建，文件纯在继续添加类容， add 为变量名 
print('hello',file=add)# file拿到路径与格式，''添加类容为hello。
add.close()# 关闭
```

## 注释

````py
#     // 表示单注释

'''
代码体
'''   //表示多注释
````

## 数据类型注意

### 常用的数据类型

1. int

2. float

3. bool  True,False

   ### bool类型

   ```py
   True #默认为1
   False#默认为0
   ```

   ### 字符串类型

   ``` python
   str1='人生苦短，我用java'#单行显示
   str2='''
   人生苦短，
   我用java
   '''            #换行显示
   ```

   

``` py
string名=“” //sreing名不用空格
print(string名) ///string名完整输出！！！！
```

``` py
print(string名[1]) // 读取字符串的下标显示，
print(string名[1:5]) // 多少到多少
```

``` py
n1=8.1
n2=1.1
from decimal import Decimal#导入一个模块 ，作用是让小数运算，精度不丢失。
print(Decimal('8.1')+Decimal('1.1'))  
```

### 数据类型转换

``` python
str()
int()
float()
```

1. str()#print()输出 字符串与数字的可用str（）转化为字符串，因为print 不可以同时输出 有字符串的变量与数字的变量
2. int（）#只可以转换数字类型，小数转换整数会精度丢失
3. float()#加.0

## 定义函数（方法）

``` py
def 方法名（ 变量名,变量名）:
a = b + c
result a// 返回值

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

//调用方法
方法名 (传入参数)

```

### 转义字符

\加字母  （字母为功能的实现） 

1. \n为换行
2. \t 为空格  一个\t  4个字符位
3. \r 显示后面的
4. \b 往左退一个格，覆盖一个
5. \\ \ 可以让print输出‘’的字符，在内容里面插入\'\ 内容' \

``` python
print("hello \n Python")#\n表示换行
print(r"hello \n Python")# r"" ,使用r可以让反斜杠不发生转义，并且显示
print()
```

## 变量与值

``` python
name='马里奥'

```

变量内存组成：标识，类型，值

1. id(变量名name )//标识#获取变量的内存地址   ！！！！ 值相同，ID标识相同
2. type(变量名name)//类型#获取类型
3. name#值

## input用户输入函数

``` py
// input 读取用户输入的值默认为 str类型 ！！！ 如有需要可以转换，观看下面装换方法
变量名 = input（“请输入”）
```

``` python
a=int(input('请输入')) #输入时就转换为int
```

``` python
a=int('请输入')
a=int(a)
```

``` python
print(int(a))
```

## 运算符

### 基础运算符

``` python
+
-
*
/
//  #整除
% #取模 与整除有相似
** #幂运算   2**4 为2的4次方
```


### 赋值运算符

``` python
解包赋值//a,b,c=1,2,3#a=1,b=2,c=3
可以调换位置！ a,b,c=c,a,c# a=c,b=a,c=c
```

``` python
a-=10#a=a-10
b%=10#b=b%10
```

### 比较运算符

id的比较#比较地址

```python
参数 is 参数 # is 相等
参数 is not 参数 # is not 不相等
```

python小扩展

``` python
print(a>b)# pring 里面可以做比较，返回 True 或False
```

### 布尔运算符

``` python
not 参数# 取反 真就假
```

``` python
in #判断是否存在
使用方法： print("值" in 仓库) #仓库为变量，意思就是 值 是否 存在这个仓库。
not in#顾名思义，判断是否 不 存在
```

### 位运算符

1. 左移动：高位溢出，低位补0

``` python
值<<1   #把看二进制，向左移动1位。二进制转换后为最终结果十进制:值*2
```

​    2.右移动：地位溢出，高位补0

``` python
值>>1   #把看二进制，向右移动1位。二进制转换后为最终结果十进制:值/2
```

​    3.位& ：两值 二进制 一 一 比较 ，对应为1，结果进制位数1，否则 为0  //            8与4 为10进制 记得转二进制

``` python
print(8&4) 
```

​    4.位|：两值 二进制 一 一 比较 ，对应为0，结果进制位数0，否则 为1  //            8与4 为10进制 记得转二进制

``` python
print(8|4)
```

### 运算符的优先级


``` python
算术 》位 》比较 》布尔 //有括号()的例外
```

## 程序结构

### 对象的布尔

使用内置函数 bool（）

1. False 2. 数值0 3.None 4.空字符串 5.空列表 6.空元组 7.空词典 8.空集合 //都默认为False

2. 

   ``` python
   print(bool(''))
   print(bool(0))
   print(bool(false))
   print(bool(None))
   print(bool(0.0))
   print(bool([])) #空列表
   print(bool(List()))#空列表
   print(bool(()))#空元组
   print(bool(tuple()))#空元组
   print(bool({}))#空字典
   print(bool(dict()))#空字典
   print(bool(set()))#空集合选择结构
   ```

### 选择结构

#### if单条件

``` python
if 条件 :
    
```

#### if双条件

``` python
if 条件 :
    代码体
else:
    代码体
```

#### if多条件

``` python
if 条件 :
    代码体
elif 条件 :
    代码体
else:
    代码体
```

#### 条件表达式

``` python
print(  真代码体  if条件else 假代码体  )#简化了if的使用。// 字符串连接，有数值要str（）转换。
```

代码举例

``` python
num_a=input("输入a值")
num_b=input("输入b值")
#两数比较大小
print(str(num_a)+'大于'+str(num_b) if num_a>num_b else str(num_a)+'小于'+str(num_b) )
```

pass的语句//是一个占位符，

``` python
if 条件 {
    pass
} # 用了可以暂时不写，程序不会报错
```

## 循环

### range函数

生产一个序列，与java数组有类似

``` python
a=range(起始值，结束值)#不包含结束值的本身
a=range(1,10)#配合list（）可以让他依次显示出来
print(list(a))
```

``` python
a=range(起始值,结束值,步长) #隔几个数到下一个数
a=range(结束值)#默认起始值为0
//结束值不为本身
```

### white循环

``` python
white 条件 :
```

### for in 循环

``` python
in 表示从(字符串 或 序列 里依次取值)
```

``` python
for_in range:  #_ 占位 通过range(999) 设置循环次数为999
for i in range(100,1000) #在for in 和 i 配合可以让他依次显示出来  方便了许多 ，免list（）
```

### else

``` python
fro....
            //break 跳出不执行else
else
```

``` python
while...
        break 跳出不执行else
else
```

### 知识总结


## 列表

***python里面的列表，等同于java里面的数组***

***索引也叫下标***

***从做到右是起始值[0]开始，从右到左起始值[-1]开始***

获取列表长度len()

### 列表的创建方式

1. ```python
   #使用中括号[]
   adda=['马里奥','三木童子','千手柱间','皮皮虾','内涵段子','马里奥']
   # 使用函数list()
   add=list(['马里奥','三木童子'])
   //接下来我要使用它
   print(add[0],adda[-2])
   ```

``` python
列表名=[i for i in range(1,10)]
```

### 索引的查找

``` python
#通值和限定查找范围，来找的到，它的下标
#一堆索引里面有 相同 的值 ，只输出一个，小  下标。
变量名.index()
print(add.index(’皮皮虾‘)) #得出’皮皮虾’索引为 3
print(add.index('皮皮虾',2,4))#限定 索引2到4（不包括4本身） 范围找 '皮皮虾'的 索引 号 
```

### 切片

``` python
切片包括起始本身，不包括结束
下面为写法
1+2的原理
add=list([1,5,6,8,6,4,3,6,7])
print(add[6:2:-1]) # 包括起始，不包括结结束。
print(add[2:6:2]) 
print(add[::-1]) #默认起始为 最后一位
print(add[6::-1])
print(add[6:])    后面
print(add[:6]) 前面
```

### 列表的判断

***列表的遍历就将列表 依次输出***

``` python
遍历   for test in range(adda)
print(test)
```

``` python
判断列表里面的值是否存在  ## 多是上一章节讲过的，记得的练习
adda=['马里奥','三木童子','千手柱间','皮皮虾','内涵段子','马里奥']
print ( '马里奥' , in, adda )
print(    '马里奥' ,not int , adda)
```

### 列表元素加值

``` python
//() 可以是变量名或者是值。
append()#在列表的末尾加  一个  元素
变量名.extend(变量名2)# 在列表的末尾至少加一个元素
insert(索引,值)# 在列表的任意 位置（本身）加 一个 元素 ，
切片[ 前面:]# 在列表任意位置至少加一个元素，一刀砍只要前面。
```

### 列表元素删除

``` python
变量名.remove ( 值 )
一次删除一个元素
重复元素删除只第一个
```

``` python
变量名.pop( 索引 )
# 删除指定索引的值
() 是空就删除索引最后一个的值
```

``` python
变量名.clear()#（）空    清空列表
del 变量名 # 删除列表
切片 adda[1:3]= [] # 删除里面的范围 [] 里面有值就是修改

```

### 排序

``` python
adda=list([1,5,6,3,4,6,7,2,4,6,3,6,3,2,])
adda.sort()#()默认False 升序
adda.sort(reverse=True)# 降序
//方法二，生成新的数组排序
新的变量=sorted(adda)# 升序

变量.reverse #数值翻转
```

### 遍历

``` python
for 名1 in 名2值 //遍历依次输出
    print(名1)
```

### 总结


## 字典

键不可以重复，值可以重复

``` python
//字典创建方式
字典名={ 键 : 值 }# 键可以是字符串     元素与元素 ，分割
字典名=dict()
```

``` python
字典元素的获取
print(adda[键])
print(adda.get(键))
print(adda.get('麻花'，99))#不存在提供的默认值
```

``` python
判断 是否存在
print(键 in 字典名)
print（键 not in 字典名）
```

``` python
#键的删除
del 字典名[键]
#新增
字典名[键]=值  #修改也是一样的
```

## 元组的创建方式

``` python
组名=(值,值,值,值)
#使用元里面有一个元用 后跟,
组名=(10,)
组名=tuple( (值,值,值,值))
```

``` python
#元组里面  增加一列表里面的值   append
add=(9,[9,5],4)
add[1].append(100)
print(add)
```

## 集合

``` python
#集合创建  与字典相似 
#字典是键不重复，集合是值不重
#集合的特点 值不会重复  是无序的

s1={值,值,值}
```

```  python
集合的特点 值不会重复  是无序的

set() #转集合 
s1=set(range(6)) rang生成0到5的整数序列 set转为集合
s1=set([]) 列表转集合 无
s1={}
```

 ### 判断集合是否存在

``` python
print(值 in 集合名) 是否存在
print(值 not in 集合名) 是否不存在
```

### 添加集合元素

``` python
集合名.add(值) #单个添加
集合名.update({值,值,值})# 多个添加 除放集合，还可以放列表 ([]) 还可以 元组( () )
```

### 删除集合元素

 ``` python
 集合名.remove(值)#删除指定元素 ，不存在就异常
 集合名.discard()#删除指定元素 ，不存不抛异常
 集合名.pop()#里面不可以有值，随机删除
 ```

### 集合的关系

1. ``` python
   print(集合名A == 集合名B)        ！=
   ```

2.  ``` python
    # 判断 B 是否 为 A子集 #   b里面有A的元素
     (A2.issubset(A1)) #a2在a1里面吗
    ```

   

   ``` python
   ## 判断 A 是否 为 B超集 #   b里面有A的元素,B是A的子集，那A一定是B超子级
   (A1.issuperset(B))
   ```

   ``` python
   #判断是否没有有交集
   A1.isdisjoint(A2)
   ```

### 集合的数学运算

#### 求交集

``` python
a&b
```

#### 求并集

``` python
a|b
```

#### 求差集

```  python
a-b # a-b   a的相同的去掉，剩下的a值为差集
```

#### 对称差集

``` python
a^b  # a-b 去掉相同 剩下a和b的值 为对称差集 
```

### 集合生成公式

``` python
{i for i in range()}
```

## 知识总结



## 字符串

### 字符串的查找

``` python
名.index()#第一次出现的位置 无找到报异常 
名.find()#第一次出现的位置 无找到报-1
名,rindex()#最后出现的值 无找到报异常
名.rfind()#最后出现的值 无找到报-1
```

### 字符串的替换的连接

``` python
名.replace(旧值,新值)
# 名.replace(旧值,新值,1)  1替换多少个值
```

``` python
#连接，数字需要转换。 
print("*".join(变量名))# ,替换*
```

### 字符串的比较

``` python
> < >= <= == ！
## 阿斯码值
```

### 知识总结


## 函数

### 函数的创建与调用

#### 创建

``` python
def 函数名(形参)
    函数体
    return *
```

``` python
#创建了一个函数名为calc的函数
def calc(a,b):
    c=a+b
    return c
```

### 调用

``` python
函数名(实参)
```

``` python
result=calc(10,30) # (a=10,b=30)
print(result)
```

### 函数内存分析

``` python
在函数的调用过程中，进行参数的传递 如果是不可以变对象 函数体的修改不会影响 实参 的值。#变量名的内存地址是根据 值 而 改 变 的
// 如果是可变对象 函数体修改的值 会影响到实参#变量名的内存地址是根据  值 改 变 而  不  变 得
```

### 函数的参数定义

#### 个数可变的位置参数

``` python
无法确定传递的位置的实参的个数 可用可变位置参数 用*定义 结果为一个元组 // 
def po(*a):
    print(a)

po(1,3,4,6,78,6)
```

#### 个数可变关键字形参

``` python
无法确定传递关键字的实参的个数 可用可变关键字形参 用*定义  用** 定义 结果为一个字典

def po(**a):
    print(a)
    
po(a=1,b=3,"小明=70) 
```

``` python
#组合写法
 def po(a,*b,**c)
 def po(*b,**c)
```

#### 函数的作用域

``` python
def po(a,b):                        def po(a,b):
                                        global c
                                           c=a+b    
    c=a+b            #   局部变量           print(c)
    print(c)                                                    // 使用 global 可以转为全局变量
```

### 知识总结


### Python异常

``` python
try ... except... else ...finally

```

``` python
try:
    n1=int(input("请输入"))
    n2=int(input("请输入2"))
    c=n1/n2
except BaseException as e:
    print("出错了")
    print(e)
else:
    print("成功了",c)
finally:
    print('无论代码是否异常照样执行')
print("程序结束")
```


## 面向对象

 ### 类

#### 类的创建

``` python
class 类名 :
```

``` python
def
在类里面定义的叫 实例方法
在类外面定义的叫 函数
```

### 对象

#### 对象的创建

1. 创建对象 又称为 ***类的实例化***

``` python
# 类
class Add :     #类对象
    def dog(name,age):
        print(name)
        print(age)
        return name,age
```

``` py
# 创建对象
usa= Add()      usa实例对象
usa=Add
```

***根据类对象创建的对象 叫 实例对象***

``` python
类对象
    在的类的里面
```

``` python
实例对象
    在类的外面
```

``` python
实例名=类名
```

``` python
class Student:
    difan='吉林'
    def __init__(self,name,age):
        self.name=name #self.name 为实例属性 ,  赋值
        self.age=age

    def eat(self): #实例方法   在这 self调用本身的意思
        print("我是你爹")
    @staticmethod
    def md():
        print("静态方法，md()里面不写参数，使用了  @staticmethod 进行修饰")
    @classmethod
    def cm(cls):
        print("我是类方法，使用了@classmethod修饰")
#创建Student类对象
sul=Student("老爹","61" )
sul.eat()
print("---------------------------")
#写法二
Student.eat(sul)
```

### 类属性 类方法 静态方法

#### 类属性的调用

``` python
类名.类属性
```

1. 类属性是 本类里面所有 对象共享的

#### 类方法

``` python
类名,方法名 #          （cls）
```

#### 静态方法

``` python
类名.方法名
```

### 动态绑定属性和方法

``` python
#动态绑定属性
实例对象.自定义  属性名= 自定义 值 
实例对象.自定义的 属性名#使用
```

``` python
#动态绑定方法
实例对象.自定义名字=方法名 #定义
实例对象. 自定义的名字#使用

```

### 知识总结


### 面向对象三大属性

#### 封装

 在属性前+两个_ ,是在类外访问不了。

``` python
der(实例对象) # 拿到值后可以强制访问
```

#### 继承

``` python
class 子类名(父类1,父类2)
```

``` python
super().父类方法
```

##### 重写

``` python
def 重写方法名(self)
    super().父类方法
```

### 多态

``` python
class Dange(object):
    def red(self): 
        print('动物吃东西')
class Dog(Dange): #继承 Danege
    def red(self):    #重写
        print('狗吃屎')
class Cak(Dange):
    def red(self):
        print("猫吃薄荷")
        
class pa: ####特性
     def red(self):
        print("人吃五谷")
        
def fun(obj):
    obj.red()
fun(Dog())        引用子类对象
```

``` python
实现多态
要有继承，重写， 父类引用向子类的对象
```

### 特殊属性和特殊方法


``` py
实例对象.__dict__使用     
```

``` python
.__add__() #连接和相加的作用
```

### 浅拷贝

``` python
第一步
import copy #导入copy模块
新的实例对象=copy.copy(拷贝的实例对象)  
#拷贝源对象    拷贝的实例对象是源对象
```


### 深拷贝

``` python
第一步
import copy #导入copy模块
新的实例对象=copy.deepcopy(拷贝的实例对象)
#拷贝对象的所有子对象
```

## 模块

####  导入模块

``` python
import 模块名称 #这个导入可以使用模块的所有方法
模块名称.功能
from 模块名称 import 功能 # 使用某个模块某个功能
print(功能)
```

### 导入自己模块

``` python
import 文件名 然后
```


### 以主程序运行

避免 我导入的 模块一起运行 与模块无关的类容

``` python
 #模块的程序
    if _name_ = = '_ main _ '
        无关类容
```

### python的包

``` python
import 包名.模块名
print(包名。模块.函数) #使用 
 #=================
    
  #启用 别名会方便很多
import 包名.模块名 as a
print(a.函数) 
#=====================
form 包名 import 模块
form 包名.模块 import 函数或变量
```

### 常用模块


### 第三方模块安装与使用

``` python
#打开命令管理器
pip install 模块名
import 模块名

```

## 文件操作

#### 文件的读取

``` python
 file=open('地址'，操作方式)
 操作方式：r读文件 
print(file.readlines())#readlines()读取
file.close()
```

### 文件的常用打开方式


``` python
可以边读边写
```

### 文件对象的常用方法


``` python
file=open('地址'，操作方式)
操作方式：r读文件 
print(file.readlines())#readlines()读取 如上
file.close()
```

### with语句

``` python
with open('地址','格式') as 实例对象:   #用完会自动关闭 避免了 实例对象.close()
```

### os模块


```python
#先导入 os 模块
import os
os.listdir()
```

### os.path