Python【Python基础】

python的使用

1、python的两个版本：python2.0与python3.0。这两个版本的区别在于python3是不向下兼容python2的组件和扩展的，但是在python2.6和2.7的两个版本中将会继续兼容python2.0和3.0两个版本。简单点说就是python2.6与2.7是2.0版本向3.0版本的过渡版本，同时python的2.7版本也将是最后一个2.0版本，之后将全部使用python的3.0版本。

Windows中python3.x的安装:

1 下载安装包
2 https://www.python.org/downloads/
3 安装
4 默认安装路径：C:\python27
5 配置环境变量
6 【右键计算机】--》【属性】--》【高级系统设置】--》【高级】--》【环境变量】--》【在第二个内容框中选中变量名为Path的一行，点击编辑】 --> 【将Python安装目录追加到变值值中，用；分割】
7 如：原来的值;C:\python27，切记前面有分号

2、.pyc文件是由.py文件编译后的二进制文件，由python的虚拟机去执行，只要执行.py就会生成.pyc文件。　　

第一个python程序

在屏幕上输出： Hello Word!

首先在linux中创建hello.py脚本(所有Python程序的命名都要以.py结尾，表明这是个Python程序)

1 #!/usr/bin/env python3　　　　#声明python解释器;由于在linux中可能安装在不同的位置，所以用env去PATH路径中自动寻找
2 # -*- coding:utf-8 -*-　　　　#支持中文字符集
3 print("Hello Word!")
4 chmod +x hello.py　　　　　　　#加入执行权限
5 ./hello.py　　　　　　　　　　　#执行hello.py脚本

python的语法规范

在python书写代码的时更应该做到规范：所有级别的代码缩进必须是相同的。应当注意在不同的操作系统中tab键的使用，在我们常用的Windows与linux系统中，tab键自行缩进的空格数是不同的（Windows系统中tab默认是4个空格，这也是符合开发的基本规范）。建议大家在Windows系统中进行python程序的编写。python的缩进是强制缩进，同一逻辑层次级别的代码缩进必须保持一致。

python的变量

变量的使用规则：变量名只能是由数字、字母、下划线组成，并且不能以数字开头定义变量。注意：变量名不能和内置的关键字相同！Python区别大小写字母！

变量的作用：指向内存中某个地址里面的内容

字符串

字符串是由多个子串构成的一个整串元素，其中的每个元素都是一个子串，从左一次查询是从0开始，从右依次查询是从-1开始；字符串不可以修改，只能重新定义。

python中对字符串的操作主要有如下几种，替换、删除、截取、复制、连接、比较、查找、分割等。

•strip, 去空格以及特殊符号，去除的是首尾的

1 a = '123,'
2 b = a.strip(',') #去除','
3 b = '123'

•capitalize,首字母变大写

1 a = 'qwer'
2 a.capitalize() #首字母变大写
3 Qwer

•center,内容居中，空白处可以添加符号

1 name = 'alex'
2 name.center(10,'*') #输出字符串长度为10，其中alex居中
3 '***alex***'

•endswith,判断是否以某字符串结尾

1 name = 'alex'
2 name.endswith('x') #匹配则返回True
3 True
4 name.endswith('a') #不匹配则返回False
5 False

•startswith,判断是否以某字符串开头

1 name = 'alex'
2 name.endswith('a') #匹配则返回True
3 True
4 name.endswith('x') #不匹配则返回False
5 False

•isalnum,判断是否是字母和数字组成

1 name = 'alex123'
2 name.isalnum() #字符串由数字和字母组成返回True
3 True
4 name = 'alex_123'
5 name.isalnum() #字符串包含了其他字符返回False
6 False

•isalpha,判断是否是字母

1 name = 'alex'
2 name.isalpha()
3 True
4 name = 'alex123'
5 name.isalpha()
6 False

•count,计算某个子字符串的个数，可以给定查找范围

s = 'djsswuigdsasa'
print(s.count('s', 1, 5))
2  # 输出

•find,判断字符串中书否存在某个子串，存在返回0，不存在返回-1

s = 'sadf'
print(s.find('ss'))
print(s.find('s'))
-1  # 输出
0

•index,查询某个子串的的索引值

s = 'sd'
print(s.index('d'))
1  # 输出

•isdigit,判断是否为数字

1 name = '123'
2 name.isdigit()
3 True
4 name = 'alex'
5 name.isdigit()
6 False

列表[list]

列表是python中常用的一种数据类型，列表中的每一个元素都有自己的索引，索引值从0开始计算；列表有以下基本操作：索引、切片、追加、删除、长度、循环、包含等。

•创建列表

1 list1 = list() #创建一个空列表；
2 list = [1,2,3] #创建列表的同时加入其它元素

•访问列表中的元素

1 list1 = [1,2,3,4,5]
2 list1[0] = 1
3 list1[1:2] = 2
4 ist1[1:] = [2,3,4,5]

•append,追加列表中的元素

1 list1 = [1,2,3]
2 list1.append(11) #默认在列表的末尾追加
3 list1 = [1,2,3,11] 

•clear清空列表

1 list1 = [1,2,3]
2 list1.clear()
3 list1 = []

•关于深浅拷贝

copy,浅拷贝：只是拷贝数据的第一层，例如

1 a = [1,2,3,[4,5,6]]
2 b = a.copy()
3 #当列表a中的二层列表发生变化，b中的二层列表也发生变化。
4 a[3][0] = 0
5 b = [1,2,3,[0,5,6]]#b列表也发生变化
6 #当a列表的第一层发生变化了，b列表的第一层不会发生变化
7 a[0] = 0
8 b = [1,2,3,[4,5,6]] #此刻只有a列表发生了变化，b列表没有改变

copy.deepcopy,深拷贝：将数据的多层进行拷贝，例如

1 import copy #需要导入copy
2 a = [1,2,3,[4,5,6]]
3 b = copy.deepcopy(a)
4 #当列表a中的二层列表发生变化，列表b不发生改变
5 a[3][0] = 0
6 b = [1,2,3,[4,5,6]] #列表b为改变

•del,删除列表中的元素

1 a = [1,2,3]
2 del a[0]
3 #此刻列表a删除了下标为0的元素
4 a = [2,3]

•count,统计列表中某个元素的个数

1 a = [1,2,3,1]
2 a.count(1)
3 2 #表示列表a中元素1的个数为2

•extend,合并列表

1 a = [1,2]
2 b = [3,4]
3 a.extend(b)
4 #此刻列表a的值发生改变
5 a = [1,2,3,4]
6 #此刻列表b的值为改变
7 b = [3,4]

•index,索引，获取某个元素的索引值

1 a = [1,2,3]
2 a.index(3)
3 2

•insert,往列表中插入值

1 a = [1,2,3]
2 a.insert(1,0) #往列表a的索引值为1的位置插入元素0
3 a = [1,0,2,3]

•pop,删除列表中的元素,根据索引值删除

1 a = [1,2,3]
2 b = a.pop(0) #删除索引值为0的元素
3 a = [2,3]
4 b = 1

•remove,删除列表中的元素，指明元素删除

1 a = [1,2,3]
2 a.remove(2) #删除列表a中的元素2
3 a = [1,2]

•reverse,倒序排列列表中的元素

1 a = [1,2,3]
2 a.reverse()
3 a = [3,2,1]

•sort,根据ASCII码来对列表排序

1 a = [1,4,3,2]
2 a.sort()
3 a = [1,2,3,4]

字典[dict]

字典是python中的另外一种常用的数据类型，由键和值组成；字典有一下操作

•创建字典

1 #创建一个空字典
2 a = dict()
3 #创建一个普通字典
4 a = {'k1':1,'k2':2}

注意：字典中键和值之间用‘：’分割，每队键值用','分割，整体放在{}中

• 访问字典中的值

1 a = {'k1':1,'k2':2}
2 a['k1'] = 1 #获取键为k1的值

•clear,清空字典

1 a = {'k1':1,'k2':2}
2 a.clear() #清空字典a
3 a = {}

•copy,如同列表，分为深浅拷贝，此处略

•fromkeys,获取字典中的键，可以进行重新赋值

1 a = {'k1':1,'k2':2}
2 b = dict.fromkeys(a,2) #获取字典a的键并且重新赋值为2
3 b = {'k1':2,'k2':2}

•get,获取字典中键对应的值

1 a = {'k1':1,'k2'；2}
2 a.get('k1') #获取k1的值
3 1
4 a.get('k3','None') #获取k3的值,不存在键则输出None
5 'None'

•items,把字典中的键值对组成一个元组，并且把这些元组放在一个列表中返回

1 a = {'k1':1,'k2':2}
2 a.items()
3 [('k1',1),('k2',2)] #输出一个列表，其中包含键值的元组

•keys,以列表的形式输出字典中的键

1 a = {'k1':1,'k2':2}
2 a.keys()
3 ['k1','k2']

•pop,删除指定键和对应的值

1 a = {'k1':1,'k2':2}
2 a.pop('k1') #删除k1和k1的值
3 a = {'k2':2}

•popitem,随机删除键和对应的值

1 a = {'k1':1,'k2':2}
2 a.popitem() #随机删除字典a中的键和对应的值

•setdefault,如果字典中不存在某个键则创建，不指定值则会默认为None

1 a = {'k1':1,'k2':2}
2 a.setdefault('k1',2) #如果字典a中存在k1，字典a不会被修改
3 a = {'k1':1,'k2':2}
4 a.setdefault('k3',1) #创建键为k3，值为1的键值对
5 a = {'k1':1,'k2':2,'k3':1}

•update,根据两个字典的不同更新字典

1 a = {'k1':1,'k2':2}
2 b = {'k1':111,'k3':3}
3 a.update(b) #把字典a更新
4 a = ['k1':111,'k2':2,'k3':3] #字典a中原有的键值对更新，添加新的键值对
5 b = {'k1':111,'k3':3} #字典b不会发生改变

•values,获取字典中的值，以列表形式输出

1 a = {'k1':1,'k2':2}
2 a.values()
3 [1,2]