Python入门经典（以java思维让你掌握Python）由于是外连接图片丢失，之后会完善

Python入门经典（以java思维让你掌握Python）由于是外连接图片丢失，之后会完善 Python入门 编码格式声明

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

print函数

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

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

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

open函数

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

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

注释

#     // 表示单注释
​
'''
代码体
'''   //表示多注释

数据类型注意 常用的数据类型

1. int

2. float

3. bool True,False

   bool类型

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

   字符串类型

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

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

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

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

数据类型转换

str()
int()
float()

1. str()#print()输出 字符串与数字的可用str（）转化为字符串，因为print 不可以同时输出 有字符串的变量与数字的变量

2. int（）#只可以转换数字类型，小数转换整数会精度丢失

3. float()#加.0

定义函数（方法）

def 方法名（ 变量名,变量名）:
a = b + c
result a// 返回值
​
---------------------------
​
//调用方法
方法名 (传入参数)
​

转义字符

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

1. n为换行

2. t 为空格 一个t 4个字符位

3. r 显示后面的

4. b 往左退一个格，覆盖一个

5. 可以让print输出‘’的字符，在内容里面插入' 内容'

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

变量与值

name='马里奥'
​

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

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

2. type(变量名name)//类型#获取类型

3. name#值

input用户输入函数

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

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

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

print(int(a))

运算符 基础运算符

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

赋值运算符

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

a-=10#a=a-10
b%=10#b=b%10

比较运算符

id的比较#比较地址

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

python小扩展

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

布尔运算符

not 参数# 取反 真就假

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

位运算符

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

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

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

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

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

print(8&4) 

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

print(8|4)

运算符的优先级

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

程序结构 对象的布尔

使用内置函数 bool（）

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

2. 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单条件

if 条件 :
    

if双条件

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

if多条件

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

条件表达式

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

代码举例

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的语句//是一个占位符，

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

循环 range函数

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

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

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

white循环

white 条件 :

for in 循环

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

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

else

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

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

知识总结

列表

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

索引也叫下标

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

获取列表长度len()

列表的创建方式

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

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

索引的查找

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

切片

切片包括起始本身，不包括结束
下面为写法
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]) 前面

列表的判断

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

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

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

列表元素加值

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

列表元素删除

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

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

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

排序

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 #数值翻转

遍历

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

总结

字典

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

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

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

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

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

元组的创建方式

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

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

集合

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

s1={值,值,值}

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

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

判断集合是否存在

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

添加集合元素

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

删除集合元素

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

集合的关系

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

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

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

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

集合的数学运算

求交集

a&b

求并集

a|b

求差集

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

对称差集

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

集合生成公式

{i for i in range()}

知识总结

字符串 字符串的查找

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

字符串的替换的连接

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

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

字符串的比较

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

知识总结

函数 函数的创建与调用

创建

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

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

调用

函数名(实参)

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

函数内存分析

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

函数的参数定义

个数可变的位置参数

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

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

个数可变关键字形参

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

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

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

函数的作用域

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

知识总结

Python异常

try ... except... else ...finally

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

面向对象 类

类的创建

class 类名 :

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

对象

对象的创建

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

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

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

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

类对象
	在的类的里面

实例对象
	在类的外面

实例名=类名

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)

类属性 类方法 静态方法

类属性的调用

类名.类属性

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

类方法

类名,方法名 #          （cls）

静态方法

类名.方法名

动态绑定属性和方法

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

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

知识总结

面向对象三大属性

封装

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

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

继承

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

super().父类方法

重写

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

多态

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())        引用子类对象

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

特殊属性和特殊方法

实例对象.__dict__使用     

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

浅拷贝

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

深拷贝

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

模块

导入模块

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

导入自己模块

import 文件名 然后

以主程序运行

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

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

python的包

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

常用模块

第三方模块安装与使用

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

文件 *** 作

文件的读取

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

文件的常用打开方式

可以边读边写

文件对象的常用方法

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

with语句

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

os模块

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

os.path