1.注释
Python注释有单行注释和多行注释
- 单行注释以 “#” 开头
- 多行注释使用三个单引号（’’’）或三个双引号（"""）
注意：
单行注释描述下列语句作用；多行注释描述函数的功能、参数和返回值。
2.Python的输入与输出
input和 output统称为IO，是命令行下最基本的输入和输出.
（1）input（）输入
input0会把用户通过键盘输入的任何值都作为字符串来存储过变量
print（"hello, world")（2）print（）输出
用 print()在括号中加上字符串，就可以向屏幕上输出指定的文字
name= input("请出入你的名字")
print（"我输入的名字："+name)
# 请出入你的名字tf（tf为手动输入，输入完成后敲击回车）
# 我输入的名字：tf注意：print默认输岀是换行的，如果要实现不换行需要在变量末尾加上end=""。
# print函数可以同时输出多个字符串
print ("hello","python!!!")
# print函数默认输出带换行，可以使用可选参数end=来取消
print(1,end="")
print(2,end="")
print(3,end="")
print(4,end="")
# 输出结果：1234
# 用空格来分割输出数字
print(1,end=' ')
print(2,end=' ')
print(3,end=' ')
print(4,end=' ')
# 输出结果：1 2 3 43.变量
- 变量是程序中运算的对象：
- 变量需要程序员自己定义
- 定义后要给变量初始化
- 变量的值可以被改变
- 变量是占用内存空间的
# 求正方形面积：
# a为用户输入的正方向边长
a=int(input('请输入正方向的长：'))
# 定义正方形面积s
s=a*a
print('正方形的面积为：',s)4.变量命名
变量命名要符合PEP8规范，驼峰命名法
5.Python语法格式缩进
- 缩进强迫大家写出格式化的代码
- 当语句以’:'结尾时，缩进的语句视为代码块
- 约定俗成管理，4个空格为一个缩进
- Python大小写敏感
# 判断变量a的值大于：
a=99
if a >=0:
print('a大于等于0')
else:
print('a小于0')6.分支结构
- 流程：计算机执行代码的顺序就是流程
- 流程控制：对计算机代码执行顺序的管理就是流程控制
- 流程分类：流程控制一共分为三类
- 顺序结构
- 分支结构/选择结构
- 循环结构
（1）单项分支
age= 30
if age>=18:
print('your age is',age)
print('adult')（2）双向分支
age =13
if age>=16:
print('your age is',age)
print('adult')
else:
print('your age is', age)
print('teenager')（3）多项分支
if<条件判断1>：
<执行1>
elf<条件判断2>：
<执行2>
elf<条件判断3>：
<执行3>
else：
<执行4>age = 20
if age>=6:
print('teenager')
elif age>=18:
print('adult')
else:
print('kid')
# 输出结果：teenager7.循环结构
（1） while型循环
while循环和 break
#1到100求和
n=1
while n<=100:
if n>10: #当n=11时，条件满足，执行 break语句
break # break语句会结束当前循环
print(n)
n=n+1
print('END')
# 输出结果
‘’‘
1
2
3
4
5
6
7
8
9
10
END
’‘’- while循环，只要条件满足，就不断循环，条件不满足时退出循环
- 在循环中， break语句可以提前退出循环
- 注意：死循环就是循环不会终止的循环类型
#计算1——100的累加和
i=1
sum=0
while i<=100:
sum=sum+i # 将每次循环的累加到sum变量中，用新的sum值覆盖旧的sum值
i+=1
print('100的累加值=',sum)
#输出结果：100的累加值= 5050死循环
#死循环的应用
while True:
k= input('请输入一个值：')
print('输入的内容是',k)（2） for….in循环
#1到10求和
sum =0
for x in[1,2,3,4,5,6,7,8,9,10]:
sum= sum +x
print(sum) # 1 3 6 10 15 21 28 36 45 55
print(sum) # 55
#遍历list
names=['小红','小军','小明']
for name in names:
print(name) #小红 小军 小明
for i, n in enumerate([10,20,30]):
print(i,n)
# 输出结果
'''
0 10
1 20
2 30
'''
#遍历元组
for i in(10,40,88):
print(i)
#遍历set
for i in{10,40,88}:
print(i)
#遍历字典
a={'name':'yh','age':20,'sex':'male'}
for i in a:
print(i,':',a[i])
# 输出结果
'''
name : yh
age : 20
sex : male
'''
print(a.items())
# 输出结果:
# dict_items([('name', 'yh'), ('age', 20), ('sex', 'male')])
for k,v in a.items():
print(k,v)
# 输出结果
'''
name yh
age 20
sex male
'''
b=[('name', 'yh'), ('age', 20), ('sex', 'male')]
for v1,v2 in b:
print(v1,'=>',v2)
# 输出结果
'''
name => yh
age => 20
sex => male
'''（3）range函数
（4）break和 Icontinue语句及循环中的else子句
8.函数
函数是代码的抽象与封装。（不关心底层的具体实现过程，直接在抽象的基础之上考虑问题）
函数的本质就是功能的封装，和对代码的抽象函数的作用
- 避免开发重复性相同代码
- 便于程序的理解与维护
- 对底层代码的抽象
基本函数格式：
def函数名():
函数功能代码...
函数功能代码...
return（没有 return默认返回None）
调用函数：函数名()特征:函数定义之后不会自动执行必须在调用后才会执行
函数名的命名规则：驼峰+动词开头
带参数的函数格式：
def函数名(参数,参数,......):
函数功能代码...
函数功能代码...
return（没有 return默认返回None）
调用函数：函数名(参数,参数,......)- 形参：形式上的参数声明函数时0中的参数是形参
- 实参：实际上的参数调用函数时0中的参数是实参
- 注意：实参将值传递给形参的过程本质上就是简单的变量赋值仅此而已
- 参数须以正确的顺序传入函数。调用时的数量必须和声明时的一样
函数参数格式
- 默认值的参数：可选择性输入的参数
- 可变参数：可以输入0到任意个参数，函数内组装成tupe
- 关键字参数：可以输入0到任意个含参数名参数，函数内组装成个dict
- 命名关键字参数
- 多种参数混合：顺序是必选，默认，可变，命名关键字，关键字
函数返回值
调函数根据执行完毕是否可以得到一个结果，将函数分为2个类型
1.执行过程函数：print()
2.具有返回值的函数id()，type()
- return的特征
1.具有 return语句的函数称为具有返回值的函数
2.return可以为当前函数执行完毕返回一个结果，这样的函数调用可以被接受
3.return执行之后，函数则会终止，所有 return之后的语句不会被执行
4.一个函数可以书写多个 return语句，但是一般会放入分支结构当中
5.一个函数若要返回多个数据，可借助复合数据类型（ist, tuple,set,dict）来操作即可！
6.不带参数值的 return语句返回None
函数文档
- 函数文档就是用来查看当前函数相关信息介绍的一个特定格式而已
- 查看函数文档的方法
1.help（函数名称）#直接输出显示函数文档的内容字符串
2.函数名，doC#直接输出显示函数文档的内容元字符串（转义字符不转义）
3.官方文档 - 定义函数的文档：’’'或"""
def函数名（参数…）
'''
在此处声明函数文档
'''
函数功能代码...- 注意：函数文档的作用是对函数迸行说明，便于阅读和快速掌握函数的使用，通常函数文档需要具有以下信息：
1.函数的作用
2.函数的参数介绍（个数，数据类型）
3.函数的返回值（数据和类型）
内置函数
#abs() 函数为取一个数的绝对值，注意参数的类型、数量不可以给错，否则会报错
print(abs(-234)) # 234
#查看帮助文档
help(abs) # 参数为函数的名字
# max()函数为取最大值，参数个数为2个或多个
print(max(2,9,0,8,10))数据类型转换
#数据类型转换
print(int('123')) # 输出：123
print(int(123.456)) # 输出：123
print(float('123')) # 输出：123.0
print(str(123.456)) # 输出：123.456
print(type(str(123.456))) # 输出：<class 'str'>
print(bool(1)) # 输出：true自定义)函数
（1）当前文件内自定义abs()函数
#自定义abs()函数
def my_abs(x):
if x>0:
return x
else:
return -x
print(my_abs(-99)) #输出：99（2）新建文件自定义abs()函数
新建my_test.py文件
def my_abs(x):
'''
自定义abs函数
:param x: int，float
:return: abs值（绝对值）
'''
if not isinstance(x,(int,float)):
raise TypeError('只能输入int和float类型')
if x>0:
return x
else:
return -x在demo.py文件中
# 引入my_test.py文件中的my_abs函数
from my_test import my_abs
print(my_abs(-56)) # 输出:56
# help查看函数说明文档
help(my_abs)
# __doc__ 查看
my_abs.__doc__
# 输出
'''
my_abs(x)
自定义abs函数
:param x: int，float
:return: abs值（绝对值）
'''
my_abs('abc')
# 输出
'''
TypeError: 只能输入int和float类型
'''返回多值
#返回多值
def getNamme():
return 'yh','mike'
name1,name2 = getNamme()
print(name1,name2) # 输出：yh mike
t = getNamme()
print(t) # 输出：('yh', 'mike')
print(type(t))# 输出：<class 'tuple'>默认参数
'''
默认参数
def power(x,n=2): （在不影响原有参数的基础上进行升级更新，但参数名不变）
n=2 为默认参数
在函数调用时
power(2) 一个参数时，n默认为2；
power(2,3)两个参数时，n被赋予新的值
'''
def power(x):
return x*x
def power(x,n=2):
s=1
while n>0:
s=s*x
n= n-1
return s
print(power(2)) # 输出 4
print(power(2,3)) # 输出 8可变参数
# n个数求和
'''
第一种方式
'''
def my_sum(numbers):
sum = 0
for n in numbers:
sum = sum + n
return sum
print(my_sum([4,5,6])) # 输出 15
'''
第二种方式
'''
def my_sum(*numbers):
sum = 0
for n in numbers:
sum = sum + n
return sum
print(my_sum(5,6,1)) # 输出 12
# 通过list列表调用可变参数
nums = [1,2,3]
print(my_sum(*nums)) # 输出 6关键字参数
# 关键字参数
def student(name,age,**kw):
print('name:',name,'age:',age,'others:',kw)
# 输出 name: yh age: 18 others: {'sex': 'male', 'region': 'china'}
student('yh',18,sex='male',region='china')
# 通过字典传入
dicts={'city':'beijing','sex':'female'}
student('mike',78,**dicts)
# 输出 name: mike age: 78 others: {'city': 'beijing', 'sex': 'female'}def student(name,age,**kw):
if 'city' in kw:
pass
print('name:',name,'age:',age,'others:',kw)
# 空方法
def study():
pass
def student(name,age,*,city):
print('name:',name,'age:',age,'city:',city)
student('yh',48,city='beijing')
# 输出 name: yh age: 48 city: beijing
'''
a,b 表示必选参数
c=0 表示默认参数
*ages 表示0个或多个参数
**kw 表示0个或多个关键字参数
'''
def f1(a,b,c=0,*ages,**kw):
pass
'''
*,d 表示可选参数，但只接受参数名为d的参数
'''
def f2(a,b,c=0,*,d,**kw):
pass全局变量域局部变量
# 全局变量域局部变量
'''
定义在函数内部的变量拥有一个局部作用域，定义在函数外的拥有全局作用域
局部变量只能在其被声明的函数內部访问，而全局变量可以在整个程序范围内访问。
调用函数时，所有在函数内声明的变量名称都将被加入到作用域中
'''
name='zhangsan'
def fun():
global name # 声明全局变量
print('函数内输出全局变量：',name)
name='lisi'
print('函数内部修改后的全局变量：',name)
age = 30
print('age:',age)
fun()
# 输出
'''
函数内输出全局变量： zhangsan
函数内部修改后的全局变量： lisi
age: 30
'''
print('name:',name) # 输出 name: lisi9.面向对象编程
面向对象编程
- 面向对象编程是一种程序设计思想
- 面向对象把类和对象作为程序的基本单元
- 对象包含属性和方法
- 面向过程编程为：函数的调用集
- 面向对象编程为：对象之间传递信息的集
- 处处皆对象
# 面向过程
stu1 = {'name':'xiaoming','score':98}
stu2 = {'name':'xiaohong','score':81}
# 函数
def print_score(stu):
print('%s:%s'%(stu['name'],stu['score']))
# 面向对象
# 1.设计类
# 属性和方法
class Student(object):
# 方法 self指向创建的实例本身
def __init__(self,name,score):
self.name = name
self.score = score
def print_score(self):
print('%s:%s'%(self.name,self.score))
# 实例化对象1
xiaohong = Student('xiaohong',81)
print(id(xiaohong)) # 输出 53803184
# 实例化对象2
xiaoming = Student('xiaoming',98)
print(id(xiaoming)) # 输出 201976016
# 实例化对象3
xiaoming = Student('xiaoming',98)
print(id(xiaoming)) # 输出 52780400
print(xiaoming.name,xiaoming.score) # 输出 xiaoming 98
xiaoming.print_score() # 输出 xiaoming 98类和实例
- 类可以理解为图纸或者模版
- 实例是根据类的图纸或者模版创建出来的一个一个对象
- 类定义cass，关键字sef
- 类的初始化函数**init**
- 面向对象三大特点：继承，封装，多态
- 属性和方法
'''
继承，封装，多态
'''
class Student(object):
# 方法 self指向创建的实例本身
def __init__(self,name,score):
self.name = name
self.score = score
def print_score(self):
print('%s:%s'%(self.name,self.score))
def get_grade(self):
if self.score>=90:
return 'A'
elif self.score>=60:
return 'B'
else:
return 'C'
xiaoLv = Student('xiaoLv',45)
print(xiaoLv.get_grade()) # 输出 C访问限制
- 通过“_”两个下划线可以修饰私有变量
- 通过编写get和set方法来修改对象的属性
- Python中没有真正的私有属性和私有方法
'''
访问限制
'''
xiaoLv.score=90
print(xiaoLv.get_grade())
class Student(object):
# 方法 self指向创建的实例本身
def __init__(self,name,score):
self.__name = name
self.__score = score
def print_score(self):
print('%s:%s'%(self.__name,self.__score))
def get_grade(self):
if self.__score >= 90:
return 'A'
elif self.__score >= 60:
return 'B'
else:
return 'C'
def set_score(self,score):
if 0<=score<=100:
self.__score=score
else:
raise ValueError('分数请大于0小于等于100')
def get_score(self):
return self.__score
xiaoLv = Student('xiaoLv',45)
# 不可访问私有变量
# print(xiaoLv.score) # 报错 AttributeError: 'Student' object has no attribute 'score'
# 可访问方法
print(xiaoLv.set_score(80)) #输出 None
print(xiaoLv.get_score()) # 输出 80
#print(xiaoLv.set_score(120)) #输出 ValueError: 分数请大于0小于等于100
# python 没有真正的私有，把私有名改为_Student__name
print(xiaoLv._Student__name) # 输出 xiaoLv类属性和实例属性
'''
类属性
'''
# 实例属性 必须通过初始化或者实例化对象，通过对象去访问
class Student(object):
def __init__(self,name):
self.name = name
s = Student('Bob')
print(s.name) # 输出 Bob
# 类属性 不需要实例化对象，直接通过类名访问
class Student(object):
name = 'Student'
print(Student.name) # 输出 Student10.第三方模块的安装与使用
使用模块
- 一个.py文件称之为一个模块（ Module）
- 好处
- 便于代码维护，把很多函数放到不同文件，一个.py文件的代码数量少
- 一个模块可以被其他地方引用，代码不必从零写起
- 使用模块还可以避免函数名和变量名冲突。相同名字的函数和变量完全可以分别存在不同的模块中
- 模块分内置模块和第三方模块
- 好处
- Python解释器把一个特殊变量__name__置为__main__，而如果在其他地方导入该heo模块时，if判断将失败
- 使用 import hello s！/usr/bin/eny python
新建test_packeage包，包下新建my1.py文件，文件下添加 my1_test()函数
def my1_test():
pass另一个包下的文件，如demo包下的test.py文件
#!/usr/bin/env python3
# -*- coding:utf-8 -*-
'说明模块用途的地方'
__author__ ='yh'
def test():
print('test()调用成功')
if __name__ == '__main__':
test()
from test_packeage.my1 import my1_test安装第三方模块
- pip install Pillow
- 使用 Python的另一个发行版本， Anaconda
- Pycharm里面安装
在Pycharm里面安装步骤
本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。
