python基础语法二

json

json其实就是字典格式，可以与字典互换

字典转json

import json
stu={'name':'tom','age':13,'sex':'male'}
json_stu=json.dumps(stu)
print(json_stu=)

json转字典

json.loads(json_stu)

字符串

字符串的三种表示方式：普通字符串，原始字符串和长字符串
转义符

在普通字符串前面加上r就是原始字符串 例如：r’hello\n worid’
长字符串用三个单引号或者双引号括起来"""或者‘’‘

字符串与数字的相互转换：

将字符串转换为数字，可以用int()和float()实现，如果成功，返回数字，否则引发异常。

>>> int("80")
80
>>> int("80.0")
Traceback (most recent call last):
  File "<pyshell#1>", line 1, in <module>
    int("80.0")
ValueError: invalid literal for int() with base 10: '80.0'
>>> float("80.0")
80.0
>>> int("AB")
Traceback (most recent call last):
  File "<pyshell#3>", line 1, in <module>
    int("AB")
ValueError: invalid literal for int() with base 10: 'AB'
>>> int("AB",16)
171

将数字转换成字符串，使用str()函数

>>> str(123)
'123'
>>> money=123.123
>>> str(money)
'123.123'
>>> str(True)
'True'

格式化字符串

format()进行格式化

占位符

使用{}表示

>>> i=32
>>> s='i*i='+str(i*i)
>>> s
'i*i=1024'
>>> s='i*i={}'.format(i*i)
>>> s
'i*i=1024'
>>> s='{0}*{0}={1}'.format(i,i*i)
>>> s
'32*32=1024'
>>> s='{p1}*{p1}={p2}'.format(p1=i,p2=i*i)
>>> s
'32*32=1024

格式化控制符位于占位符索引或占位符名字的后面，之间用冒号分隔。语法：{参数序号：格式控制符}或者{参数名：格式控制符}

money=5852.122
name='tom'
str='{0:s}年龄{1:d},工资是{2:f}元'.format(name,20,money)
print(str)
str1='{0:s}年龄{1:d},工资是{2:0.2f}元'.format(name,20,money)
print(str1)
str2='{0}今天收入是{1:G}'.format(name,money)
print(str2)

操作字符串

字符串查找

find():查找自字符串,语法为str.find([sub[,start[,end]])表示为：在索引start到end之间查找子字符串sub，如果找到就返回最左端位置索引，没找到返回-1

str='hello world'
sub_s=str.find('e')
print(sub_s)
sub_s1=str.find('l')
print(sub_s1)
sub_s2=str.find('l',4)
print(sub_s2)
sub_s3=str.find('l',4,6)
print(sub_s3)

字符串替换

使用replace()方法替换子字符串，语法为str.replace(old,new[,count])
用new子字符串替换old子字符串，count参数制定了替换old子字符串的个数，如果count省略，则替换所有

text='AB CD EF GH IJ'
t=text.replace(' ','|',2)
print(t)
t1=text.replace(' ','|')
print(t1)

字符串分割

使用split()方法
str.split(sep=None,maxsplit=-1）

text='AB CD EF GH IJ'
t=text.split(' ')
print(t)
t1=text.split(' ',maxsplit=0)
print(t1)
t2=text.split(' ',maxsplit=1)
print(t2)
t3=text.split(' ',maxsplit=2)
print(t3)

函数

定义函数

def 函数名（形式参数列表）：
函数体
return 返回值

# coding=utf-8

def rect_area(width,height):
    area=width*height
    return area

def print_area(width,height):
    area = width * height
    print("{0}x{1} 长方形面积：{2}".format(width,height,area))

#调用函数
r_area=print_area(320,400)

#函数默认值
def make_coffe(name='卡布奇诺'):
    return "制作一杯{0}咖啡.format(name)"

coffee1=make_coffe()
coffee2=make_coffe("拿铁")
print(coffee1)
print(coffee2)

可变参数

# *可变参数在函数中被组装成一个元组

def sum(*num):
    total=0
    for n in num:
        total+=n
    return total

print(sum(10,20,30))

# **可变参数在函数中被封装成一个字典
def show_info(**info):
    print("---------")
    for key,value in info.items():
        print('{0}-{1}'.format(key,value))

show_info(name='tom',age=18,sex='female')

局部变量与全局变量

x=20
def print_value():
    x=10
    print('x={0}'.format(x))

print_value()
print('全局x={0}'.format(x))

x=20
def print_value():
    global x#将x变量提升为全局变量
    x=111
    print('x={0}'.format(x))

print_value()
print('全局x={0}'.format(x))

函数类型

一个函数可以作为另一个函数的返回值使用，也可以作用另一个函数的参数使用

def add(a,b):
    return a+b

def sub(a,b):
    return a-b

def calc(opr):
    if opr == '+':
        return add
    else:
        return sub

f1=calc("+")
f2=calc("-")
print("10+5={0}".format(f1(10,5)))
print("10-5={0}".format(f2(10,5)))

过滤函数

filter()函数

语法：filter(function,iterable)—iterable会被遍历，它的元素会被逐一传入function()函数中。若function()返回true被保留.filter()返回值不是一个列表，需要用list()转换

def f1(x):
    return x>50

data1=[20,20,123,14,46,66,82,1245,4,2]
filter1=filter(f1,data1);

data2=list(filter1)
print(data2)

映射函数

map()

语法：map(function,iterable)

def f1(x):
    return x+2

data1=[20,20,123,14,46,66,82,1245,4,2]
map1=map(f1,data1);

data2=list(map1)
print(data2)

lambda()函数

格式：lambda 参数列表:lambda体

def calc(opr):
    if opr == '+':
        return lambda a,b:(a+b)
    else:
        return lambda a,b:(a-b)

f1=calc("+")
f2=calc("-")
print("10+5={0}".format(f1(10,5)))
print("10-5={0}".format(f2(10,5)))

递归函数

递归函数：重复进行调用某个函数，直到不符合某个条件，结束调用

类与对象

定义类

class 类名[(父类)]：

class Car(object):
    pass

car=Car()

class Dog:
    #__init__是构造方法，初始化实例变量
    def __init__(self,name,age):
        self.name=name
        self.age=age

d=Dog('tom',1)
print('我家狗名叫{0},{1}岁了'.format(d.name,d.age))

class Dog:
    #__init__是构造方法，初始化实例变量
    def __init__(self,name,age,sex='雌性'):
        self.name=name
        self.age=age
        self.sex=sex


d1=Dog('tom',1)
d2=Dog('monica',1,'雄性')
d3=Dog(name='花花',sex='雄性',age=3)

print('我家狗名叫{0},{1}岁{2}'.format(d1.name,d1.age,d1.sex))
print('我家狗名叫{0},{1}岁{2}'.format(d2.name,d2.age,d2.sex))
print('我家狗名叫{0},{1}岁{2}'.format(d3.name,d3.age,d3.sex))

实例方法

实例方法：使用 def 关键字来定义一个方法，与一般函数定义不同，类方法必须包含参数 self,且为第一个参数，self 代表的是类的实例。实例方法只能被实例对象调用

class Dog:
    #__init__是构造方法，初始化实例变量
    def __init__(self,name,age,sex='雌性'):
        self.name=name
        self.age=age
        self.sex=sex

    def run(self):
        print("{}在跑".format(self.name))

    def speak(self,sound):
        print("{}在叫，{}!".format(self.name,sound))

d1=Dog('tom',1)
d1.run()
d1.speak("汪汪汪")

静态方法

由@staticmethod装饰的方法,没有self这个参数，而将这个方法当成一个普通的函数使用。可以被类或类的实例对象调用

#静态方法‐‐‐》公共方法：类和对象公用
@staticmethod
def static_method():
	print("这是一个静态方法")

类变量

通过类名直接调用，不需要实例化对象调用

class Dog:

    legs='四条腿'#类变量，通过类名调用
    #__init__是构造方法，初始化实例变量
    def __init__(self,name,age,sex='雌性'):
        self.name=name
        self.age=age
        self.sex=sex

    def run(self):
        print("{}在跑".format(self.name))

    def speak(self,sound):
        print("{}在叫，{}!".format(self.name,sound))

d1=Dog('tom',1)
d1.run()
d1.speak("汪汪汪")`在这里插入代码片`
print("狗都有{}".format(Dog.legs))

类方法

class Dog:

    legs='腿'#类变量，通过类名调用
    #__init__是构造方法，初始化实例变量
    def __init__(self,name,age,sex='雌性'):
        self.name=name
        self.age=age
        self.sex=sex

    @classmethod
    #类方法‐‐‐‐》公共方法：类和对象公用
    def legNum(cls,num):#cls代表类自身
        return  str(num)+'条'+cls.legs

legnum=Dog.legNum(4)
print("狗都有{}".format(legnum))


-------------------------------------------------------------------------
print结果：
狗都有4条腿

封装性

私有变量

在变量前加上双下划线__即可
在类的内部可以访问私有变量，在类的外部不能访问私有变量

私有方法

在方法前加上双下划线__即可
在类的内部可以访问私有方法，在类的外部不能访问私有方法
在类中不应该存在公有成员变量，设计为私有，通过get和set取值赋值

class Dog:

    def __init__(self,name,age,sex='雌性'):
        self._name=name
        self._age=age
        self.sex=sex

    def get_age(self):
        return self._age

    def set_age(self,age):
        self._age=age

dog=Dog("球球",2)
print("年纪：{}".format(dog.get_age()))
dog.set_age(3)
print("修改后年纪：{}".format(dog.get_age()))

--------------------------------------------------------------------------------
年纪：2
修改后年纪：3

实例对象调用私有变量

class Dog:

    def __init__(self,name,age,sex='雌性'):
        self._name=name
        self._age=age

    #定义age属性的get()方法，使用@property装饰器，方法名就是属性名
    @property
    def age(self):#替代get_age(self)
        return self._age

    @age.setter
    def age(self,age):#替代set_age(self,age)
        self._age=age

dog=Dog('球球',2)
print('狗狗年纪{}'.format(dog.age))
dog.age=3
print('狗狗修改后年纪{}'.format(dog.age))


-------------------------------------------------------------------------------
狗狗年纪2
狗狗修改后年纪3

继承性

class Animal:
    def __init__(self,name):
        self.name=name

    def show_info(self):
        return "动物的名字:{0}".format(self.name)

    def move(self):
        print("move move")

class Cat(Animal):
       def __init__(self,name,age):
        super().__init__(name)#调用父类构造方法
        self.age=age

cat=Cat('tom',2)
cat.move()
print(cat.show_info())

-------------------------------------------------------------------------------
move move
动物的名字:tom

多继承

python可以继承多个父类，如果在多个父类中有相同的成员方法或者变量，则子类优先继承左边父类的成员方法或者变量

class Horse:
    def __init__(self,name):
        self.name=name

    def show_info(self):
        return "马名字:{}".format(self.name)

    def run(self):
        print("马儿跑")

class Donkey:
    def __init__(self,name):
        self.name=name

    def show_info(self):
        return "驴名字:{}".format(self.name)

    def run(self):
        print("驴儿跑")

    def roll(self):
        print("驴打滚")

class Mule(Horse,Donkey):
    def __init__(self,name,age):
        super().__init__(name)
        self.age=age

m=Mule('小骡子',1)
m.run()
m.roll()
print(m.show_info())

--------------------------------------------------------------------------------
马儿跑
驴打滚
马名字:小骡子

方法的重写

子类重写父类方法

class Horse:
    def __init__(self,name):
        self.name=name

    def show_info(self):
        return "马名字:{}".format(self.name)

    def run(self):
        print("马儿跑")

class Donkey:
    def __init__(self,name):
        self.name=name

    def show_info(self):
        return "驴名字:{}".format(self.name)

    def run(self):
        print("驴儿跑")

    def roll(self):
        print("驴打滚")

class Mule(Horse,Donkey):
    def __init__(self,name,age):
        super().__init__(name)
        self.age=age

    def run(self):#子类重写父类方法
        print("{}在跑".format(self.name))

m=Mule('小骡子',1)
m.run()

--------------------------------------------------------------------------------
小骡子在跑

多态性

class Animal:
    def speak(self):
        print('动物叫。。')

class Dog(Animal):
    def speak(self):
        print('小狗汪汪叫')


class Cat(Animal):
    def speak(self):
        print('小猫汪汪叫')

an1=Dog()
an2=Cat()
an1.speak()
an2.speak()
--------------------------------------------------------------------------------
小狗汪汪叫
小猫汪汪叫