python基础（2）—— 基础语法

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 4

3.变量

• 变量是程序中运算的对象：
• 变量需要程序员自己定义
• 定义后要给变量初始化
• 变量的值可以被改变
• 变量是占用内存空间的

# 求正方形面积：
# 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. 顺序结构
2. 分支结构/选择结构
3. 循环结构

（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')
# 输出结果：teenager

7.循环结构

（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.函数

函数是代码的抽象与封装。（不关心底层的具体实现过程，直接在抽象的基础之上考虑问题）

函数的本质就是功能的封装，和对代码的抽象函数的作用

1. 避免开发重复性相同代码
2. 便于程序的理解与维护
3. 对底层代码的抽象

基本函数格式：

def函数名():
	函数功能代码...
	函数功能代码...
	return（没有 return默认返回None）
调用函数：函数名()

特征:函数定义之后不会自动执行必须在调用后才会执行
函数名的命名规则：驼峰+动词开头

带参数的函数格式：

def函数名(参数,参数,......):
	函数功能代码...
	函数功能代码...
	return（没有 return默认返回None）
调用函数：函数名(参数,参数,......)

• 形参：形式上的参数声明函数时0中的参数是形参
• 实参：实际上的参数调用函数时0中的参数是实参
• 注意：实参将值传递给形参的过程本质上就是简单的变量赋值仅此而已
• 参数须以正确的顺序传入函数。调用时的数量必须和声明时的一样

函数参数格式

1. 默认值的参数：可选择性输入的参数
2. 可变参数：可以输入0到任意个参数，函数内组装成tupe
3. 关键字参数：可以输入0到任意个含参数名参数，函数内组装成个dict
4. 命名关键字参数
5. 多种参数混合：顺序是必选，默认，可变，命名关键字，关键字

函数返回值
调函数根据执行完毕是否可以得到一个结果，将函数分为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: lisi

9.面向对象编程

面向对象编程

• 面向对象编程是一种程序设计思想
• 面向对象把类和对象作为程序的基本单元
• 对象包含属性和方法
• 面向过程编程为：函数的调用集
• 面向对象编程为：对象之间传递信息的集
• 处处皆对象

# 面向过程

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) # 输出 Student

10.第三方模块的安装与使用

使用模块

• 一个.py文件称之为一个模块（ Module）
• 好处

1. 便于代码维护，把很多函数放到不同文件，一个.py文件的代码数量少
2. 一个模块可以被其他地方引用，代码不必从零写起
3. 使用模块还可以避免函数名和变量名冲突。相同名字的函数和变量完全可以分别存在不同的模块中

• 模块分内置模块和第三方模块
• 好处

1. Python解释器把一个特殊变量__name__置为__main__，而如果在其他地方导入该heo模块时，if判断将失败
2. 使用 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里面安装步骤