python基础

其他

• python存储数据的方法 ：先在内存中存储数据后，再用标签引入
• python对大小写敏感
• 获取地址 id()
• 获取数据类型 type()
• 判断类型isinstance (x,int) x是否为int型
• python中通过缩进来控制结构层次
• 查看某功能的使用方法： help（名称）
• 加载库的语句是： import + 库的名字
• 调用库中某功能的语句： 库名.功能
• ctrl+/ 注释多行
• 解释某个库的用法： 双击，Ctrl加q
• IDE 是 PyCharm 时
  • 代码块：右移：直接 Tab、左移：Shift + Tab
• python库的
  • 安装：pip install 库名 -i https://pypi.tuna.tsinghua.edu.cn/simple
  • 卸载 ： pip uninstall 库名

变量

在一行中为多个变量赋值

x, y, z = "Orange", "Banana", "Cherry"

交换a b的值

a,b=b,a

+号连接字符

x = "awesome"
print("Python is " + x)

数据类型

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

• Number（数字）
  • int
  • float
  • bool
  • complex（复数）
• String（字符串）
• List（列表）
• Tuple（元组）
• Set（集合）
• Dictionary（字典）
• 不可变数据（3 个）：Number（数字）、String（字符串）、Tuple（元组）
• 可变数据（3 个）：List（列表）、Dictionary（字典）、Set（集合）
• type() 函数获取任何对象的数据类型

数据类型转化

• frozenset(s) 转换为不可变集合
• chr(x) 将一个ascll转换为一个字符
• ord(x) 将一个字符转换为它的ascll值
• hex(x) 将一个整数转换为一个十六进制字符串
• oct(x) 将一个整数转换为一个八进制字符串
• set(s) 转换为可变集合
• int()转换为整型
• str()转换为字符型
• float()转换为浮点型
• eval() 类型随意转换 :将字符类型转换为其他类型

输入输出

基础字符串操作

• .upper()

  把你输入的字符串类型变量转化成全部大写

• .lower()

  把你输入的字符串类型变量转化成全部小写

• .split()

  把你给它的任何变量撕成一个列表。如果不带参数，它默认会以空格” ”作为切分标记

• %字符串插值

  给定 'string % ' % values，则 string 中的 % 实例会以零个或多个 values 元素替换

  如

  print('The value is %5.2f' % 3)
  
  # 结果为The value is  3.00
  

• format

print('We are the {} who say {}'.format('knights', 'Ni'))
# 结果为 We are the knights who say "Ni!"

• 花括号和其中的字符（称为格式字段）将替换为传递给 str.format()方法的对象。花括号中的数字可用来表示传递给 str.format() 方法的对象的位置

  • 保留小数

  print("{:.2f}".format(12.333)) #此处为保留两位小数
  #结果为 12.33
  

  • 百分比

  print("{:.2%}".format(1))
  # 结果为 100.00%
  

输入

input

• input() 函数接受一个标准输入数据，返回为 string 类型。可以在括号里添加提示，如

  input('Give me your input!')
  

• 同时输入多个值

  a,b,c=input().split(' ')  #输入a，b，c时 将a、b、c用空格隔开 
  

输出

print

• 用.split()控制输出格式

a='1-32-46-5'
print(a.split("-"))#以-为切分符号
#结果为['1', '32', '465']

处理序列

(序列类型:字符串、元祖、列表)

通用操作符

s + t 表示连接 s、t 两个序列

s*n 表示s序列重复n次

in 判断元素是否在序列中。

s[i] 索引,返回s中的第i个元素,i是序列的序号,正下标正向找,负下标逆向找

s[i:j:k] 切片,返回序列s中第i到j以k为步长的元素子序列 倒序y=x[::-1] 注：切片时必须在最后字符后再加1，因为python只会截取到最后字符的前一个字符。

函数和方法:

len(s) 返回序列s长度

min(s) 返回序列s的最小元素

max(s) 返回序列s的最大元素

s.index(x,i,j) 返回序列s从i开始到j位置中第一次出现元素x的位置

s.count(x) 返回序列s中出现x的总次数

b.join(a) 方法用于将序列a中的元素以指定的字符b连接生成一个新的字符串 a='49685' b='+' c=b.join(a) 结果4+9+6+8+5

排序内置函数 sorted()

列表（list）

• 格式 []
• 列表的数据项不需要具有相同的类型，无论那是字符、字符串或者是另一个列表。
• 可变类型 ，更改后其地址（id），仍然不变

索引

索引从0开始计数

如

b=['w','q',2]
a=['a','sd',b]
print(a[2][0])
#结果为 w

切片

• 格式：[::]，第一个参数，是开始切割的位置，第二个参数，是结束切割的位置，第三个参数，是切片增量
• 倒序：[::-1]

列表推导式

以现有列表为基础创建新的列表

数字型
a=[i for i in range(20) if i%2==0]
#语法，我们使用了一个临时声明的变量x，x后面跟了一个for循环，使用range迭代返回的每一个值。这些东西都被放进了列表里
字符型
b=['NAme','Is']
b=[x.lower() for x in b]

常用方法

.append()

接收一个参数。它可以把接收到的参数放在列表的末尾

如

a=['a','d','w']
a.append('q')
a.append(1)
#结果为['a', 'd', 'w', 'q', 1]

.insert()

接收两个参数，第一个参数是我们想要在列表的那个索引位置上进行插入，第二个是我们想要插入的值

如

a=['a','d','w']
a.insert(2,'1')
#结果为['a', 'd', '1', 'w']

.remove()

删除特定的值（列表中第一次出现的），并不能根据我们给定的索引进行删除

如

a=['a','d','w','a','g','a']
a.remove('a')
#结果为['d', 'w', 'a', 'g', 'a']

.del()

删除指定索引位的值

如

a=['a','d','w']
del a[2]
#结果为['a', 'd']

cmp()

比较两个列表的元素,相同返回 0 ；a>b返回正值；a<b返回负值

len()

列表元素个数

max()

返回列表元素最大值

min()

返回列表元素最小值

count()

统计某个元素在列表中出现的次数

extend(seq)

在列表末尾一次性追加另一个序列中的多个值（用新列表扩展原来的列表）

index()

从列表中找出某个值第一个匹配项的索引位置

pop()

移除列表中的第i元素,并且返回该元素的值

reverse()

将列表中的元素反转

sort(cmp=None, key=None, reverse=False)

对原列表进行排序

copy()

复制列表的内容

如

a=['a','d','w','a','g','a']
b=a.copy()
#结果为['a', 'd', 'w', 'a', 'g', 'a']

元组与字典

元组 （tuple）

• 格式： () 只能读不能写的列表

• 注： 定义只有一个元素的元组时，要在一个元素后加逗号

  如

  a=('3',)  #类型为元组
  a=('3')   #类型为字符
  

字典（ dict）

• 格式： { : } 键值对

三个字典对应的方法

.keys()

显示字典里的所有关键字

.values()

显示所有的值

.items()

显示所有的关键字和他们的值(同时显示)

.get()

提取出字典中的值

如：a = {‘name’:’值’} 使用命令 a.get(‘name’)

集合 （set ）

• 格式：{} 不能有重复元素，只读不写，无序结构

流程控制

算术运算符

• 除/

• 乘*

• 减-

• 加+

• 取余%

• 幂次**

• //返回商的整数部分，向下取整，如，5//2`，得2

关系运算符

• >

• <

• >=

• <=

• !=

• ==

逻辑运算符

• and
• or
• not

成员运算符

用来判断一个东西(比如变量)是不是在另一个范围(比如列表/字典/元组)里面，若是返回True 否则返回False

• in
• not in

布尔类型

• True

• False

条件判断

If

else

elif

如

a=int(input())
if a==1:
    print('a=1')
elif a==2:
    print('a=2')
else:
    print('error')

循环结构

相关函数

• range()

range函数可以有三个参数，第一个参数作为下界，第二个参数作为上界，第三个参数为步长，返回一个含有数值类型的列表

如

a=range(1,10)
b=list(a)
print(b)
#结果为[1, 2, 3, 4, 5, 6, 7, 8, 9]

• len()

返回变量的长度，无论这个变量是string类型，list类型亦或是dictionary类型

for

一般用于循环次数可知

while

一般用于循环次数未知

定义函数

全局变量

在函数外声明的变量，可以在脚本程序的任意位置调用这个变量

局部变量

在函数里声明的变量，只能在函数内部被调用而不能在函数外部调用

注：如果在函数范围内定义了具有相同名称的变量，那么它将仅打印函数内给出的值而不是全局值。

自定义函数

def

• return 结束函数，选择性地返回一个值给调用方。不带表达式的return相当于返回 None。另外return 可以有多个返回值

如

def greet(name,adress):
    c='my'+name+'and'+adress
    return c

print(greet('hahah','127.0.0.1'))
#结果为myhahahand127.0.0.1

lambda

• 格式： lambda 参数 ：参数的运算式
• lambda表达式必须被赋值给某个变量才能发挥作用

如

f=lambda x,y : x+y

f(12,34)  #计算两数之和，输出：46    

• lambda操作符

  • fliter() - 可以被用来过滤原有的list，并把过滤结果放进新的list里。filter接受两个参数，第一个是lambda表达式提供的过滤条件，第二个是要进行过滤的现有列表。最后，filter返回一个符合条件的列表类型

    如

    a=[x for x in range(1,10)]
    b=filter(lambda i:i%2==0,a)#将列表中符合条件的值，过滤出来
    print(list(b))
    #结果为[2, 4, 6, 8]
    

  • map() - 可以同时对list里的所有元素进行操作，并以列表方式给出返回值

    如

    a=[x for x in range(1,10)]
    b=map(lambda i:i**2,a)#将列表里的内容都平方
    print(list(b))
    #结果为[1, 4, 9, 16, 25, 36, 49, 64, 81]
    

  • reduce() - 可以对列表顺序执行算术运算

异常处理

增加程序的稳定性(健壮性)，我们应该尽可能的考虑可能发生错误的点以及用户的使用方式，以使得程序不会轻易的崩溃

try和except

try:
    if int(a)+1 > 1 :
        print("ok")
    else:
        print('no')
except ValueError:
    pass

linux下的脚本

代码执行

可以用两种方式执行代码。一种是用python指令，另一种是用shebang。Shebang（也称为Hashbang）是一个由井号和叹号构成的字符序列#!，shebang符号可以在脚本内部指定解释器路径

#! /usr/bin/python
print 'hahah'

先赋予这个脚本文件执行权限
然后`./脚本名称`，即可运行

文件操作

手动文件I/O操作

写文件

file = open('路径','w')
file.write('内容')
file.close()

读文件

file = open('路径','r')
file.read()
file.close()

注意：定要记得把文件关上。如果不关闭文件，就会导致一些错误，文件也可能会被损坏。

自动文件I/O操作

用with关键字和as关键字来打开和关闭文件。会自动关闭文件，不需要close()函数

格式：with open(‘文件路径’，'操作方式') as 存储文件的变量名

写文件

with open('路径','w') as f:
    f.write('内容')

读文件

with open('路径','r') as f:
    f.read()

相关函数

open()

open(file, mode, buffering, encoding)

• file 文件路径（相对或者绝对路径）

• mode 文件打开模式

  • r 只读
  • w 写入，写入前删除旧内容
  • r+ 可以读文件也可以写文件

  with open('路径','r+') as file:
      test = file.read() # 读取
      file.write("123")  # 写入
  

  • rb 以二进制方式读文件
  • wb 以二进制方式写文件
  • x 创建新文件
  • a 追加
  • +更新，读写

readline()

每次读出一行内容，包括 字符。

readlines()

读取整个文件所有行，保存在一个列表(list)变量中，每行作为一个元素

strip()

使用strip去掉每行结束的

for line in file.readlines():

line=line.strip('
')

read()

接将所有的数据一次性读取出来,返回的数据类型是一个字符串

writelines()

写行数据

面向对象

概念

类：类是模板

实例：创建类的实例的意思就是用类创建了一个对象

类的属性：类的属性是用来表明这个类是什么的

实例属性：用于区分不同的实例

如

class Circle(object):
   pi = 3.14

   def __init__(self, r):
       self.r = r # 实例属性

类属性：是每个实例的共有属性

如

class Circle(object):
   pi = 3.14  # 类属性

   def __init__(self, r):
       self.r = r

定义类

使用关键字class创建一个类，还需要给这个类起个名字和继承关系

类的初始化

对自身属性赋值

• __init__函数

定义一个初始化器，它会在我们创建类的实例的时候被运行

• self

self只在类的方法中存在，self指向的是类实例对象本身(不是类本身)，通过self.属性的格式来设置成员变量

如

class man(object):
    def __init__(self):
        self.hungry = 'yes'
        self.nation = 'china'
        self.age= 12

类的方法

在类的内部，使用 def 关键字来定义方法，与一般函数定义不同，类方法必须第一个参数为 self

如

class man(object):
    def __init__(self):
        self.hungry = 'yes'
        self.nation = 'china'
        self.age= 12
    def eat(self): #定义了一个成员函数eat
        if self.hungry == 'yes':
            print("you are true")
        elif self.age == 12:
            print("age is 12")

创建实例

如

class man(object):
    def __init__(self):
        self.hungry = 'yes'
        self.nation = 'china'
        self.age= 12
    def eat(self):
        if self.hungry == 'yes':
            print("you are true")
        elif self.age == 12:
            print("age is 12")

person1 = man()
print(person1.hungry)
person1.eat()

高阶

区别：复制与赋值，y=x.copy() y=x 两者意义不同

a=['a','d','w','a','g','a']
b=a.copy()
print('a=',id(a))
print('b=',id(b))
x=123
y=x
print('x=',id(x))
print('y=',id(y))
#结果，复制地址不同，赋值地址相同
a= 1305040912448
b= 1305042195776
x= 140723598386656
y= 140723598386656