Python基础语法

Python基础-01

1.1 注释

注: 以下示例代码均以python3为主,若有python2代码 会说明

单行注释: 以#开头，#右边的所有东西当做说明

    #我是注释，可以在里写一些功能说明之类的哦
    print('hello world')

多行注释:

    '''
            我是一个
            多行注释
            额额额额
    '''
    print("这个就是多行注释！")

但是如果你用的是python2，注意要让程序支持中文:

要加上#coding=utf-8，且=号两边不能有空格

    #coding=utf-8
    #我是phython2
    print 'python2版本'

1.2 变量及类型

标准数据类型

Python3中有六个标准的数据类型：

• Number（数字）

• String（字符串）

• List（列表）

• Tuple（元祖）

• Set（集合）

• Dictionary（字典）

  ​

  **不可变数据（3个）: **Number（数字）、String（字符串）、Tuple（元组）;

  可变数据（3个）: List（列表）、Dictionary（字典）、Set（集合）。

---

1.2.1Number（数字）

Python3 支持 int 、float、bool、complex（复数）。

Python3 中,只有一种整数类型 int , 表示为长整型, 没有python2 中的 Long。

内置的 type() 函数可以用来查询变量所指的对象类型

>>> a, b, c, d = 20, 5.5, True, 4+3j
>>> print(type(a), type(b), type(c), type(d))
<class 'int'> <class 'float'> <class 'bool'> <class 'complex'>

此外还可以用 isinstance 来判断：

>>>a = 111
>>> isinstance(a, int)
True
>>>

其中 isinstance 和 type 的区别在于:

class A:
    pass

class B(A):
    pass

isinstance(A(), A)  # returns True
type(A()) == A      # returns True
isinstance(B(), A)    # returns True
type(B()) == A        # returns False

区别就是:

• type()不会认为子类是一种父类类型。

• isinstance()会认为子类是一种父类类型。

当你指定一个值时, Number 对象就会被创建:

var1 = 1
var2 = 10

您也可以使用 del 语句删除一些对象引用。例如:

del var
del var_a, var_b

数值运算:

>>>5 + 4  # 加法
9
>>> 4.3 - 2 # 减法
2.3
>>> 3 * 7  # 乘法
21
>>> 2 / 4  # 除法，得到一个浮点数
0.5
>>> 2 // 4 # 除法，得到一个整数
0
>>> 17 % 3 # 取余 
2
>>> 2 ** 5 # 乘方
32

---

1.2.2 String（字符串）

Python中的字符串用单引号 ’ 或者 ” 括起来，同时使用 \ 转义特殊字符。

同时，加号 + 是字符串的连接符， 星号 * 表示复制当前字符串，紧跟的数字为复制的次数。

字符串输出：

#Python3
>>>a="中国"
>>>b=2
>>>print("我很%d,但是我爱%s"%(b,a),end="")
>>>print(" -署名Jack")
我很2,但是我爱中国 -署名Jack

#Python2
>>>#coding=utf-8
>>>a="中国"
>>>b=2
>>>print"我很%d,但是我爱%s"%(b,a),
>>>print" -署名Jack"
我很2,但是我爱中国  -署名Jack

注意：常用 %d格式化整数，%s格式化字符串,不换行打印加上 end=”” （python3）， 如果为python2 如上 加上 ，即可

字符串输入 :

input 能够帮你完成从键盘中获取数据，然后保存到指定的变量中

注意: input获取的数据，都是以字符串的形式进行保存，即使输入的是数字，那么也是以字符串的形式进行保存

#Python3
>>>username = input("请输入用户名：")
>>>print("当前的用户名为:%s"%username)

#Python2
>>>#coding=utf-8
>>>username = raw_input("请输入您的用户名：")
>>>print "您的用户名为:%s"%username

字符串的下标与切片：

切片是指对操作的对象截取其中一部分的操作。字符串、列表、元组都支持切片操作

切片的语法: [起始：结束：步长]

选取的区间属于左闭右开型，即从“起始”位开始，到 “结束” 位的前一位结束 （不包括结束位本身）

 >>> a = "abcdef"
 >>> a[:3]
 'abc'
 >>> a[::2]
 'ace'
 >>> a[5:1:2] 
 ''
 >>> a[1:5:2]
 'bd'
 >>> a[::-2]
 'fdb' 
 >>> a[5:1:-2]
 'fd'

字符串的常见操作：

<1> find

检测str是否包含在mystr中，如果是返回开始的索引值，否则返回 -1

用法：

mystr.find(str, start=0, end=len(mystr))

示例：

mystr='hello world Jack and JackSmith'
num = mystr.find('Jack')
print(num)
>>> 12

mystr='hello world Jack and JackSmith'
num = mystr.find('Jack',0,10)
print(num)
>>> -1

<2> index

跟 find() 方法一样, 只不过如果str不在mystr中会报一个异常

用法：

mystr.index(str, start=0, end=len(mystr))

示例：

mystr='hello world Jack and JackSmith'
num = mystr.index('Jack')
print(num)
>>> 12

mystr='hello world Jack and JackSmith'
num = mystr.index('Jack',0,10)
print(num)
>>> Traceback (most recent call last):
  File "pythonFile.txt", line 2, in <module>
    num = mystr.index('Jack',0,10)
ValueError: substring not found

<3> count

返回str在 start和end之间 在mystr里面出现的次数

用法：

mystr.count(str, start=0, end=len(mystr))

示例：

mystr='hello world Jack and JackSmith'
num = mystr.count('Jack')
print(num)
>>> 2

<4> replace

把 mystr 中的 str1 替换成 str2,如果 count 指定，则替换不超过 count 次.

用法：

mystr.replace(str1, str2,  mystr.count(str1))

示例：

name='helloworld ha ha'
newName = name.replace('ha','HA',1)
print("name=%s"%name)
print("newName=%s"%newName)
>>> name=helloworld ha ha
>>> newName=helloworld HA ha

<5> split

以 str 为分隔符切片 mystr，如果 maxsplit有指定值，则仅分隔 maxsplit 个子字符串

用法：

mystr.split(str=" ", 2)

示例：

name='hello world ha ha'
newName1 = name.split(" ")
print(newName1)
newName2 = name.split(" ",2)
print(newName2)
>>> ['hello', 'world', 'ha', 'ha']
>>> ['hello', 'world', 'ha ha']

<6> capitalize

把字符串的第一个字符大写

用法：

mystr.capitalize()

示例：

mystr='hello world jack and bao'
newStr = mystr.capitalize()
print (newStr)
>>> Hello world jack and bao

<7> startswith

检查字符串是否是以 obj 开头, 是则返回 True，否则返回 False

用法：

mystr.startswith(obj)

示例：

1.4 函数

用法：

    def 函数名():
        代码

示例：

#定义函数
def printInfo():
        print('--------------')
        print('人生苦短 我用python')
        print('--------------')
#调用函数
printInfo()
>>> --------------
>>> 人生苦短 我用python
>>> --------------

1.4.1 函数的文档说明

def calculate(a,b):
        "该函数用来完成对两个数进行求和"
        print("a+b=%d"%(a+b))
calculate(1,2)
>>> a+b=3

help(calculate)
>>> Help on function calculate in module __main__:
>>> calculate(a, b)
>>>  该函数用来完成对两个数进行求和
(END) 

调用函数时，参数的顺序：

def addSum(a,b):
        print("a(%s)+b(%s)的和等于%d"%(a,b,a+b))
addSum(2,3)
>>> a(2)+b(3)的和等于5


def addSum(a,b):
        print("a(%s)+b(%s)的和等于%d"%(a,b,a+b))
addSum(b=3,a=2)
>>> a(2)+b(3)的和等于5

1.4.2 函数的返回值

在python 中我们可不可以返回多个值？

def divide(a,b):
        shang=a//b
        yushu=a%b
        return shang,yushu
sh,yu=divide(9,2)
print("a除b的商:%s,余数:%s"%(sh,yu))
>> a除b的商:4,余数:1

本质上利用了元组

1.4.3 局部变量和全局变量

如果在函数中修改全局变量，那么就需要使用 global 进行声明，否则出错

如果全局变量的名字和局部变量的名字相同，那么使用的是局部变量的

对于不可变类型的全局变量来说，因其指向的数据不能修改，所以不使用global时无法修改全局变量

对于可变类型的全局变量来说，因其指向的数据可以修改，所以不使用global时也可修改全局变量

python中交换 2个 变量的几种方式：

a=4
b=5

#第一种
c=a
a=b
b=c

#第二种
a=a+b
b=a-b
a=a-b

#第三种
a,b=b,a

其他知识点扩充：

# 1
a=[100]
def test(num):
        num+=num
        print(num)
test(a)
print(a)
>>> [100, 100]
>>> [100, 100]

# 2
a=[100]
def test(num):
        num=num+num
        print(num)
test(a)
print(a)
>>> [100, 100]
>>> [100]

1.4.4 函数参数

<1> 缺省参数

调用函数时，缺省参数的值如果没有传入，则被认为是默认值。下例会打印默认的age，如果age没有被传入

def printinfo( name, age = 35 ):
   # 打印任何传入的字符串
   print "Name: ", name
   print "Age ", age

# 调用printinfo函数
printinfo(name="miki" )
printinfo( age=9,name="miki" )
>>> Name:  miki
>>> Age  35
>>> Name:  miki
>>> Age  9

注意：带有默认值的参数一定要位于参数列表的后面

>>> def printinfo(name, age=35, sex):
...     print name
...
  File "<stdin>", line 1
SyntaxError: non-default argument follows default argument

<2> 不定长参数

加了星号（）的变量args会存放所有未命名的变量参数，args为元组；而加*的变量kwargs会存放命名参数，即形如key=value的参数， kwargs为字典。

def test(a,b,c=33,*args,**kwargs):
        print(a)
        print(b)
        print(c)
        print(args)
        print(kwargs)
test(1,2,44,55,name='张三',age=19)
>> 1
>> 2
>> 44
>> (55,)
>> {'name': '张三', 'age': 19}

注意：若元组只有单个元素，要在此单个元素后加个，表区分 是个元组，否则python解释器会把其当成一个算数表达式

<3> 拆包

若实参中 使用 * 表示拆元组,使用 ** 表示拆字典

def test(a,b,c=33,*args,**kwargs):
        print(a)
        print(b)
        print(c)
        print(args)
        print(kwargs)
#test(1,2,44,55,name='张三',age=19)
A=(44,55,66)
B={'name':'张三','age':19}
test(1,2,3,*A,**B)
>> 1
>> 2
>> 3
>> (44, 55, 66)
>> {'name': '张三', 'age': 19}

1.4.5 匿名函数

用lambda关键词能创建小型匿名函数。这种函数得名于省略了用def声明函数的标准步骤。

案例：排序

infos=[{'name':'Jack','age':19},{'name':'Smith','age':20},{'name':'David','age':25}]
infos.sort()
print(infos)
#直接排序会报错 因为解释器无法判别 是按名称还是年龄排序 所以接下来需要进行指定
>>> Traceback (most recent call last):
>>>  File "01-test.py", line 2, in <module>
>>>    infos.sort()
>>> TypeError: '<' not supported between instances of 'dict' and 'dict'

使用lambda进行指定，排序规则

infos=[{'name':'Jack','age':19},{'name':'Smith','age':20},{'name':'David','age':25}]
infos.sort(key=lambda x:x['name'])
print(infos)

>>> [{'name': 'David', 'age': 25}, {'name': 'Jack', 'age': 19}, {'name': 'Smith', 'age': 20}]

匿名函数当作实参的应用：

python2：

#coding=utf-8
def calcu(a,b,func):
        result = func(a,b)
        return result
func_new=input("请输入计算规则: ")
result=calcu(11,12,func_new)
print result

>>> 请输入计算规则: lambda x,y:x*y
>>> 132

python3：(python3中的input会把输入的内容当作字符串处理 所以要用eval 将字符串转换成表达式)

def calcu(a,b,func):
        result=func(a,b)
        return result
func_new = input("请输入计算规则：")
func_new = eval(func_new)
print(calcu(11,12,func_new))

>>> 请输入计算规则：lambda x,y:x-y
>>> -1

1.5 文件

文件的复制、粘贴

1.6 面向对象

定义一个类：

class 类名:
    函数列表

综合案例：

class cat:
        """定义了一个cat类"""

        #初始化对象
        def __init__(self,new_name,new_age):
                self.name=new_name
                self.age=new_age

        def __str__(self):
                return "%s的年龄是%d"%(self.name,self.age)
        #方法
        def eat(self):
                print("%s在吃鱼..."%self.name)
        def drink(self):
                print("%s在喝水..."%self.name)
#创建一个对象
tom=cat("汤姆猫",16)
tom.eat()
print(tom)
smith=cat("咖菲猫",1)
smith.drink()
print(smith)
>>> 汤姆猫在吃鱼...
>>> 汤姆猫的年龄是16
>>> 咖菲猫在喝水...
>>> 咖菲猫的年龄是1

注：

• 创建完对象 __init__默认执行
• 在python中方法名如果是__xxxx__()的，那么就有特殊的功能，因此叫做“魔法”方法
• 当使用print输出对象的时候，只要自己定义了__str__(self)方法，那么就会打印从在这个方法中return的数剧

__del__() 方法

由上可知，python解释器默认调用 __init__()方法

当删除一个对象时，python解释器也会默认调用一个方法，这个方法为 __del()__方法

import time
class Animal(object):
        #初始化方法
        #创建完对象后会自动被调用
        def __init__(self,name):
                print("__init__方法被调用")
                self.__name=name
        #析构方法
        def __del__(self):
                print("__del__方法被调用")
                print("%s对象马上被干掉了..."%self.__name)
#创建对象
dog = Animal("哈皮狗")
#删除对象
del dog

cat = Animal("波斯猫")
cat1 =cat
print("马上删除cat对象")
del cat
print("马上删除cat1对象")
del cat1
print("程序两秒后结束")
time.sleep(2)

1.6.1 封装与隐藏

Python中没有像C++中public和private这些关键字来区别公有属性和私有属性

它是以属性命名方式来区分，如果在属性名前面加了2个下划线__，则表明该属性是私有属性，否则为公有属性（方法也是一样，方法名前面加了2个下划线的话表示该方法是私有的，否则为公有的）

为了更好的保存属性安全，即不能随意修改，一般的处理方式为

• 将属性定义为私有属性
• 添加一个可以调用的方法，供调用

class People(object):
        def __init__(self,name):
                self.__name=name
        def getName(self):
                return self.__name

        def setName(self,newName):
                if len(newName) >= 5:
                        print("newName的长度:%s"%(len(newName)))
                        self.__name = newName
                else:
                        print("error:名字长度需要大于或者等于5")
xiaoming = People("haha")
print(xiaoming.getName())
xiaoming.setName("SmithDavid")
print(xiaoming.getName())
>>> haha
>>> newName的长度:10
>>> SmithDavid

• 私有的属性，不能通过对象直接访问，但是可以通过方法访问
• 私有的方法，不能通过对象直接访问
• 私有的属性、方法，不会被子类继承，也不能被访问
• 一般情况下，私有的属性、方法都是不对外公布的，往往用来做内部的事情，起到安全的作用

1.6.2 继承

即一个派生类（derived class）继承基类（base class）的字段和方法

单继承-示例：

# 定义一个父类,如下
class Cat(object):
        def __init__(self,name,color="白色"):
                self.name = name
                self.color = color
        def run(self):
                print("%s--跑啊跑"%self.name)
#定义一个子类
class Bosi(Cat):
        def setNewName(self,newName):
                self.name=newName
        def eat(self):
                print("%s--在吃呀吃"%self.name)
bs = Bosi("波斯猫")
print("bs的名字:%s"%bs.name)
print("bs的颜色:%s"%bs.color)

bs.eat()
bs.setNewName("波斯花花猫")
bs.run()
>>> bs的名字:波斯猫
>>> bs的颜色:白色
>>> 波斯猫--在吃呀吃
>>> 波斯花花猫--跑啊跑

说明：

虽然子类没有定义__init__方法，但是父类有，所以在子类继承父类的时候这个方法就被继承了，所以只要创建Bosi的对象，就默认执行了那个继承过来的__init__方法

多继承-示例：