python基础

1.数据类型

1.1数字类型

数字类型分为整数、浮点数、复数、布尔

整数默认十进制表示，二进制0B开头，八进制0O开头，十六进制0X开头

浮点数默认是float类型，可以使用科学技术法，1.5e-5表示$1.5 * 10^{-5}$

复数，1+2j，1是实部，2是虚部

布尔，True/False 2个值，可使用bool()函数将任意数据类型转换为bool型，空对象、列表、元组、字符串会被转换为False，其他为True

1.2字符串

python字符串类型是str，普通字符串使用单引号、双引号，包含格式的可以使用三引号，字符会受到转义字符的影响

python字符串使用Unicode编码

常用转义字符

\t	水平制表符
\n	换行
\r	回车
\''	双引号
\‘	单引号
\\	反斜线

 在字符串前加上r表示字符串完全按照原始格式输出，忽视转义字符

s = r'Hello\nWorld'
#Hello\nWorld
print(s)

使用format()方法格式化字符串

name = '张三'
age = 30
s = '我是{0},我{1}'.format(name,age)
#我是张三,我30
print(s)

使用find()方法查找子串在主串的位置

str.find(str, beg=0, end=len(string))

s = 'hello world 123 baba qwer'
#结果是6，字符串的索引从0开始，空格也算，没找到返回-1
print(s.find('world'))

2.数据结构

python中数据结构包括序列、集合、字典

2.1序列（可迭代、元素有序、可重复）

序列包括元组（tuple）、列表（list）、字符串、range？？、bytes序列

序列可以使用索引、+和*、切片

• 索引
• +和*

s = 'Hello'
#HelloHello
print(s+s)
#HelloHelloHelloHelloHello
print(s*5)

• 切片

s = 'Hello'
#[start:end]，不包括end
#Hel
print(s[0:3])
#[start:end:step]，step：索引+step为下一个元素,默认1
#0:3:2表示取索引为0,2的元素
#Hl
print(s[0:3:2])

元组（不可变序列，一旦初始化就不能更改）

• 创建元组

a = (21,22,'db')
print(a)
b = (15)
#<class 'int'>，没逗号不是元组，应是b=(15,)
print(type(b))

• 访问元组，使用索引、切片都可以

• 遍历元组，使用for循环

列表（可变序列）

#创建列表使用[]，不加[]创建的是元组
#<class 'tuple'>
t = 1,2,3,4
l = [1,2,3,4]

#追加元素
#append()只能加一个
l.append('王五')
#+=、expend()可以加多个
l += [6,7]
l.extend((8,9))

#插入元素
l.insert(0,'王零')

#替换元素
l[1] = '王一'
#['王零', '王一', 2, 3, 4, '王五', 6, 7, 8, 9]
print(l)

#删除元素
#remove()从左至右，删除第一个碰到的，没有报错
#['王零', '王一', 2, 3, 4, '王五', 7, 8, 9]
l.remove(6)

列表推导式

l = []
#把0-9中能被3整除的数平方
for i in range(10):
    if(i % 3 == 0):
        l.append(i ** 2)
#[0, 9, 36, 81]
print(l)
#列表推导式
#for之后用来选择符合条件的i,选出符合条件的i后使用for前边的语句运算返回结果
l = [i**2 for i in range(10) if (i % 3) == 0]

2.2集合（可迭代、元素无序、不可重复）

可变集合

#集合使用{}创建
a = {1,2,3}
#空集合使用set()不传参数创建，a={}创建的是空dict不是空set

#添加元素，已存在的不会添加
a.add(4)

#删除元素
#remove会在没有元素是报错，discard不会报错
a.remove(4)
a.discard(3)

#遍历集合
#集合没有索引，使用for循环遍历
for x in a:
    print(x)
    

不可变集合

#不可变集合使用frozenset()函数创建，一旦创建不可修改
s = frozenset([1,2,3,4])
print(s)

集合也有集合推导式，同列表推导式，只是把[]换成{}即可

2.3字典（可迭代、key-value对、key不可重复）

#创建字典
d = {1:'张三',2:'李四',3:'王五'}

#修改字典
d[1] = '张三丰'

#添加字典
#key没有就可以添加
d[4] = '周杰伦'

#删除字典
#使用del、pop()删除时，如果key不存在，会报错
del d[1]
d.pop(2)

#访问字典
#使用get()方法的到key对应的value
d.get(3)
#字典可以直接用[key]得到值
d[3]
#items()返回所有的key、value对
#dict_items([(3, '王五'), (4, '周杰伦')])
d.items()
#keys()返回key
#dict_keys([3, 4])
d.keys()
#values()返回value
#dict_values(['王五', '周杰伦'])
d.values()

#遍历字典
#遍历key
for k in d.keys():
    print(k)
#遍历value
for v in d.values():
    print(v)
#遍历key:value
for k,v in d.items():
    print(k,v)

#字典推导式
#key-value互换
d1 = {1:'张三',2:'李四',3:'王五'}
d1 = {value:key for key,value in d1.items()}
#{'张三': 1, '李四': 2, '王五': 3}
print(d1)

3.函数式编程

#函数使用def定义
def area(width,height=2):
    area = width * height
    #有返回值使用return返回
    print(area)
    return area

a = area(2,3)
#使用函数关键字调用，有一个用关键词调用了，就都得用关键词调用
a = area(width=2,height=3)
#函数可以有默认值，如下表示width=2，height=2
a = area(2)

可变参数

#*表示把传入的数据组装成元组
def sum(*numbers):
    sum = 0
    for number in numbers:
        print(number)
        sum+=number
    print(sum)
    return sum

#直接传入4个参数，会把4个参数组装成一个元组,最后numbers是(1,2,3,4)
a = sum(1,2,3,4)
#传入的是一个元组，会把这个元组在组装成一个元组，即numbers是((1,2,3,4),)
#a = sum((1,2,3,4))

#为了保证numbers是(1,2,3,4),需要对传入的元组使用*拆包
a = sum(*(1,2,3,4))
#可变参数不是最后一个参数,其他参数使用关键字方法传

#**表示把可变参数组装成字典
def sum(**numbers):
    sum = 0
    for k,v in numbers.items():
        sum += v
        print('第{0}个数是{1},加上它是{2}'.format(k,v,sum))

dict = {'1':1,'2':11,'3':15}
#同样需要拆包
sum(**dict)

如果函数有多个返回值，可以return一个元组

3.1生成器

如果列表元素可以按照某种算法推算出来，那我们可以在循环的过程中不断推算出后续的元素，而不必一次算出所有的元素，这样更节省内存。generator中保存的是算法，使用yield返回，然后继续向下执行，直到执行到函数的最后，结束生成器。

generator可以使用（）创建、或者把一个普通函数改成生成器函数

使用（）创建

g = (x * x for x in range(10))

把一个普通函数改成生成器函数

#斐波那契数列
def fib(max):
    n, a, b = 0, 0, 1
    while n < max:
        print b
        a, b = b, a + b
        n = n + 1
#生成器函数
def fib(max):
    n, a, b = 0, 0, 1
    while n < max:
        yield b
        a, b = b, a + b
        n = n + 1

生成器使用for循环调用

 for n in fib(6):
    print n

 4.面向对象

object类

#所有的类都继承自object类,object类有2个常用方法
#__str__():返回对象字符串表示
#__eq__():判断对象是否相等
class Person:
    #__init__()是构造方法，第一个参数self相当于java中的this，指向当前对象
    def __init__(self,name,age):
        self.name = name
        self.age = age
    #不重写__str__,使用print打印<__main__.Person object at 0x000001C5952835F8>
    #返回的是对象类名，内存地址信息
    #重写__str__,使用print打印name:张三,age15
    def __str__(self):
        return 'name:{0},age:{1}'.format(self.name,self.age)

    def __eq__(self, other):
        if(self.name == other.name and self.age == other.age):
            return True
        else:
            return False
p1 = Person('张三',15)
p2 = Person('张三',15)
#True
print(p1==p2)

Python也是面向对象编程的，因此具有封装、继承、多态

封装

#python使用__封装私有成员变量
class Person():

    def __init__(self,name,age,sex):
        self.name = name
        self.age = age
        #sex就是一个私有的成员变量，在类外不能直接访问
        self.__sex = sex

    @property#============这个注解相当于getter
    def sex(self):
        return self.__sex
    @sex.setter
    def sex(self,sex):
        self.__sex = sex
p1 = Person('张三',15,'男')
#AttributeError: 'Person' object has no attribute 'sex'
#print(p1.sex)
print(p1.sex)
p1.sex = '女'
print(p1.sex)

继承

class Person():

    def __init__(self,name,age):
        self.name = name
        self.age = age

#继承的类直接写在()里
class Student(Person):

    def __init__(self,name,age,school):
        super().__init__(name,age)
        self.school = school

s = Student('李四',15,'北大')

多态在python里意义不大，python不需要声明类型，多态的意义在于Person p = new Student()，父类引用可以调用子类重写过得方法

枚举类

import enum
class WeekDays(enum.Enum):
    MONDAY = 1
    TUESDAY = 2
    WEDNESDAY = 3
    THURSDAY = 4
    FRIDAY = 5

 

转载于:https://www.cnblogs.com/vshen999/p/10483707.html