python--基础

发表于 | 分类于
之前学过一点python，但掌握不是太好，重新开始吧

python 版本简介

新的python程序建议使用python 3.0版本的语法

python 3.x是现在和未来python的主流版本

为了不带如过多累赘，python 3.0在设计时没有考虑向下兼容

  • 为了照顾现有旧版本程序，官方提供了过滤版本– python 2.6 >,基本使用python 2.0的语法和库，允许使用部分3.0的语法与函数; python 2.7是python 2.x的最后一个版本

python快速入门

程序输出，print语句

1
2
3
4
5
>>>myString = 'hello word';
>>>pritn myString
hello
>>>myString
'hello word'

下划线( _ )表示最后一个表达式的值

1
2
>>>_
hello word

python的print语句可与字符串操作符（%）结合使用，类似于C语言中printf()函数占位符

1
2
>>> print "%s is num %d!" % ("python",1)
python is num 1

%s – 字符串
%d – 整行
%f – 浮点型
> – 重定向

下面是将输出重定向到错误日志中的demo

1
2
3
logfile = open('/tmp/mylog.txt','a')
print >> logfile,'Fatal error: invaalid input'
logfile.colse()

程序输入和raw_input()内建函数

1
2
3
4
>>> user = raw_input("inter login name:")
inter login name:root
>>> print user
root

上面是输入字符串，只能用于文本输入。下面输入一个数值字符串，并将字符串转换为数值）

1
2
3
4
>>> num = raw_input('enter a num:')
enter a num:126
>>> print int(num)*2
24

可与下面的输出进行比较

1
2
3
4
>>> num = raw_input('enter a num:')
enter a num:12.1
>>> print num*2
12.112.1

小知识
help()函数可以帮助使用生疏函数，将函数名作为help()函数的参数值，可以得到相应的帮助信息

1
2
3
4
5
6
7
8
9
10
>>> help(raw_input)
Help on built-in function raw_input in module __builtin__:

raw_input(...)
    raw_input([prompt]) -> string

    Read a string from standard input.  The trailing newline is stripped.
    If the user hits EOF (Unix: Ctl-D, Windows: Ctl-Z+Return), raise EOFError.
    On Unix, GNU readline is used if enabled.  The prompt string, if given,
    is printed without a trailing newline before reading.

操作符

1. 算术操作符

+ 、 - 、 * 、 /(地板除) 、 //(浮点除法，对结果进行四舍五入) 、 % 、 ** (幂)

2. 比较操作符

> 、 < 、 = 、 >= 、 <= 、 == 、 != 、 <> 、 >> 、 <<
结果返回布尔值

3. 逻辑运算符

and 、 or 、 not
3<4<5 等价于 3<4 and 4<5

4. 位运算符

1
2
3
4
5
6
7
8
9
设变量a=60，b=13，二进制格式如下：
-----------------------------------------------------
a = 0011 1100
b = 0000 1101
-----------------------------------------------------
a&b = 0000 1100
a|b = 0011 1101
a^b = 0011 0001
~a = 1100 0011

2

5. 成员运算符

除了以上的一些运算符之外，Python还支持成员运算符，测试实例中包含了一系列的成员，包括字符串，列表或元组。

运算符 描述
in 如果在指定的序列中找到值返回 True，否则返回 False
not in 如果在指定的序列中没有找到值返回 True，否则返回 False。

6. 身份运算符

身份运算符用于比较两个对象的存储单元

运算符 描述
is is 是判断两个标识符是不是引用自一个对象
not is is not 是判断两个标识符是不是引用自不同对象

注：is用于判断两个变量引用对象是否为同一个，==用于判断引用变量的值是否相等

变量和赋值

python中的变量名仅仅是一些字母开头得标识符——所谓字母开头，意指大写或小写字母、包括下划线_ ；其他的字符可以是数字、字母或下划线。python变量是大小写敏感的。

python是动态类型语言，不需预先声明变量类型

数

python有3中数据类型：整数、浮点数、复数（-5+3i）

注：python中不区分long int类型，默认的整数类型可以任意长。

字符串

同其他语言一样，是字符的序列

1. 单引号、双引号、三引号

单引号与双引号指定字符串，所有的空白，即空格和制表 符都照原样保留。

三引号(‘’’) 可以指定一个多行的字符串，可以在三引号中自由 的使用单引号和双引号。

1
2
3
4
5
6
7
>>> print('''aaa
... bbb
... '''
... )
aaa
bbb
ccc

2. 转义序列

使用反斜杠(\)将特殊字符进行转义
比如单引号里用单引号，双引号里用双引号，都需要将内容里的单引号进行转义

如果想指定两行字符串的话，一是用’’’,二是用转义符\n表示新的一行的开始(This is the first line\nThis is the second line )

在一个字符串中，在一行末尾的反斜杠仅仅表示下一行的字符串是上一行的继续，但并不增加新的行。

1
2
3
>>> "one.\
... two"
'one.two'

3. 自然字符串

如果，你想指定一些不被特殊处理，例如像转义序列，那么，就需要通过在字符串前面附加 r 或 R 来指定自然字符串。

例如，r'Newlines are indicated by \n'

4. 按字面意义级连字符串

如果把两个字符串按字面意思连接相邻写入，它们会被python 自动级连。
例如， "What\'s "'your name?'

5. 字符串拼接

可以使用str1.__add__(str2)或者str1 + str2或者直接两个字符串放一起,来拼接字符串

但字符串与其它类型拼接时，得先把其它类型转成字符串类型，否则会出错。如str1 + 2就会出错，需要str1 + str(2)

6. 字符串的乘法运算

“*“: 可以把字符串重复拼接若干次,如: 2 * 3 得到 6; ‘la’ * 3得到’lalala’。但乘以0或者负数时,结果将会是空字符串””

7. 字符串序列（索引和切片）

字符串可以使用下表来获取字符串中某个项目，以及截取字符串
用法如： a=’qweasd’ 则a[1]=>’w’ ; a[1:3]=>’we’ ; a[1:-1]=>’weas’

8. str(anything)函数和 unicode(anything)函数

Python 2有两个全局函数可以把对象强制转换成字符串:unicode()把对象转换成Unicode字符串，还有 str()把对象转换为非Unicode字符串。

Python 3只有一种字符串类型，Unicode字符串，所以 str()函数即可完成所有的功能。(unicode()函数在Python 3里不再存在了。)

9. format方法

类似于占位，在不想用其他信息来构造字符串时，使用format()方法很有用。

1

转为字符串的操作由 format 自动完成，而不需要明确 的转换。用 format 方法的时候，不必处理用过的变量和 vice-versa 就能改变消息。


注：

  1. 没有专门的char数据类型，确实没有需要有这个类型。
  2. 单引号和双引号字符串是完全相同的——它们没有在任何方面有不同。
  3. 正则表达式: 一定要用自然字符串处理正则表达式。否则会需要使用很多的反斜杠。
  4. 使用 help(str) 可查看字符串对象定义的所有方法及属性。
  5. 由于百分号有特殊作用，所以字符串里面要用百分号的话需要使用“%%”，如: “select * from my_table where name like ‘%%测试%%’”

字符串详细内容参见大佬博客链接：
https://blog.csdn.net/qq_33337811/article/details/78312998

对象

Python 是完全面向对象的，在某种意义上，任何东西都被作为对象，包括数字、字符串和函数。

demo: 使用变量和文字意义上的常量

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
# filename:demo1.py
i=5
print(i)

i = i+1
print(i)

s='''This is one.
this is two'''
print(s)


输出：
5
6
This is one.
this is two

注：使用变量时只需要给它们赋一个值。不需要声明或定义数据类型。

逻辑行和物理行

物理行是编写程序时所看见的。逻辑行是python看见的单个语句。python嘉定每个物理行对应一个逻辑行。
如果像在一个物理行中使用多于一个逻辑行，那么使用分毫开特别地标明这种用法。分号表示一个逻辑行语句的结束。

1
2
3
4
5
6
7
8
9
10
11
12
1 i = 5 
2 print i
等于
1 i = 5; 
2 print i;
等于
i=5;print i;  甚至写成i=5;print i
连接的话
print \ 
i
与如下写法效果相同：
print i

控制流

在python中有三种控制流：if、 for、 while

if

注意 if 语句在结尾处包含一个冒号 —— 我们通过它告诉 Python 下面跟着一个语 句块。
在 Python 中没有 switch 语句。你可以使用 if..elif..else 语句来完成同样的工作（在某些场合，使用 字典会更加快捷。）

demo:

1
2
3
4
5
6
7
8
9
10
11
#filename:if.py

number = 24
guess = int(raw_input('enter an integer:'))

if (guess == number):
	print('win')
elif (guess <= number):
	print("s");
else:
	print("b");

while

while 语句有一个可选的 else 从句

demo:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
# Filename while.py
number = 23
running = True

while running:
	guess = int(raw_input("enter a number"))

	if guess == number:
		print("win")
		running=False
	elif guess <number:
		print("s")
	else:
		print("b")
else:
	print("the while loop is over")
print("over")

结果：

1
2
3
4
5
6
enter a number24
b
enter a number23
win
the while loop is over
over

for

for...in是另外一个循环语句，它在一序列的对象上迭代，即逐一使用序列中的每个项目

else 部分是可选的。如果包含 else ，它总是在 for 循环结束后执行一次， 除非遇到 break 语句。在 C/C++ 中，如果你想要写 for (int i = 0; i < 5; i++) ，那么用 Python ，你写成 for i in range(0,5) 。你会注意到， Python 的 for 循环更加简单、明白、不易出错.

demo:

1
2
3
4
for j in range(1,5):
	print(j)
else:
	print('the for loop is over')

结果：

1
2
3
4
5
1
2
3
4
the for loop is over

break

break 语句是用来终止循环语句的，即哪怕循环条件没有变为 False 或序列还没有 被完全迭代结束，也停止执行循环语句。

如果你从 for 或 while 循环中终止，任何对应的循环 else 块 将不执行。

demo:

1
2
3
4
5
6
7
#Filename:break.py
while True:
	s = (raw_input('enter something:'))
	if s=='quit':
		break
	print('length os the string is',len(s))
print('Done')

结果：

1
2
3
4
enter something:quite
('length os the string is', 5)
enter something:quit
Done

continue

continue 语句对于 for 循环也有效。

1
2
3
4
5
6
7
8
9
10
#Filename:continue.py
while True:
	s = raw_input('Enter something:')
	if s=='quit':
		break
	if len(s)<4:
		print('small')
	continue

	print('Input is of sufficient length')

结果：

1
2
3
4
Enter something:asd
small
Enter something:asdsdas
Enter something:quit

模块

模块是python程序架构的一个核心概念

- 模块就好比是工具包，要想使用这个工具包中的工具，就需要import导入这个模块
- 每一个以扩展名py为结尾的python源代码都是一个模块,包含了 Python 对象定义和Python语句
- 在模块中定义的全局变量、函数和类都是模块能够提供给外界直接使用的工具
- 模块里也能包含可执行的代码

demo：
模块代码(mokuai.py)：

1
2
3
4
5
6
7
def sayhello():
	return 'hello,boy'

def saybey():
	return 'beybey'

name='hahah'

测试代码(ceshi.py):

1
2
3
4
import mokuai
print(mokuai.sayhello())
print(mokuai.saybey())
print(mokuai.name)


每个模块只会被导入一次，不管你执行了多少次import。
这样可以防止导入模块被一遍又一遍地执行。
模块可以让曾经编写过的代码被复用

模块命名

模块是也是标识符，命名遵循标识符的命名

Pyc文件：
c 是compiled编译过的意思

  1. 可以在程序目录看到一个pycache目录
  2. 目录下会有几个pyc文件，cpython表示python解释器的版本
  3. 这个pyc文件是由python解释器将模块的源码转换为字节码。（这样保存字节码是作为一种启动速度的优化）

字节码

python解释源程序时是分为两个步骤的，首先处理源代码，编译生成一个二进制字节码，再对字节码进行处理，才会生成CPU能够识别的机器码
有了模块的字节码文件之后，下一次运行程序时，如果上次保存字节码之后没有改过源代码，则会加载pyc文件并跳过编译这个步骤。
若是重新编译，会自动检查源文件和字节码的时间戳，修改源代码后，下次程序运行时，字节码会自动重新创建。

from…import语句

Python 的 from 语句让你从模块中导入一个指定的部分到当前命名空间中。语法如下：

from modname import name1[, name2[, … nameN]]
例如：要导入模块 fib 的 fibonacci 函数，使用如下语句：from fib import fibonacci

这个声明不会把整个 fib 模块导入到当前的命名空间中，它只会将 fib 里的 fibonacci 单个引入到执行这个声明的模块的全局符号表。

dir()函数

dir() 函数一个排好序的字符串列表，内容是一个模块里定义过的名字。
返回的列表容纳了在一个模块里定义的所有模块，变量和函数。如下一个简单的实例：

1
2
3
4
5
6
7
8
#!/usr/bin/python
# -*- coding: UTF-8 -*-
 
# 导入内置math模块
import math
 
content = dir(math)
print content;

输出：

1
2
3
4
5
6
['__doc__', '__file__', '__name__', 'acos', 'asin', 'atan', 
'atan2', 'ceil', 'cos', 'cosh', 'degrees', 'e', 'exp', 
'fabs', 'floor', 'fmod', 'frexp', 'hypot', 'ldexp', 'log',
'log10', 'modf', 'pi', 'pow', 'radians', 'sin', 'sinh', 
'sqrt', 'tan', 'tanh']
//特殊字符串变量__name__指向模块的名字，__file__指向该模块的导入文件名。

函数

varargs参数

定义一个能获取任意个数参数的函数，这可通过使用 * 号来实现。
demo:

1
2
3
4
5
6
7
8
9
10
11
12
def total(init=5,*numbers,**keywords):
	count = init
	for number in numbers:
		count += number
	for key in keywords:
		count += keywords[key]
	return count

print(total(1,2,3,apple=20,orange=30))
//1传给init, 2，3被收集进一个列表numbers
//apple=20后的所有参数都被收集为一个字典，keywords={‘apple’:20,’orange’:30}
//结果为56

当定义一个带*的参数，像*param时，从那一点后所有的参数被收集为一个叫做 ‘param’ 的列表。
类似的，当定义一个带两个*的参数，像**param,从那一点开始的所有关键字参数会被收集为一个叫做’param’的字典。

DocStrings

Python有个特性，称为文档字符串，它通常被简称为 docstrings 。它会使你的程序文档简单易懂.
你可以使用 doc（注意双下划线）调用 printMax 函数的文档字符串属性（属 于函数的名称）。函数名.doc

python还有回调函数，递归函数，内嵌函数，内置函数，匿名函数……与其他编程语言相似

内置函数

len() 求长度 || min() 求最小值 || max() 求最大值
sorted() 排序 || reversed() 反向 || sum() 求和
all() 判断给定的参数是否都为true(除了0、空、None、False外都算True)
enumerate(sequence, [start=0]) || esal() 执行一个字符串表达式

进制转换函数
bin() 转换为二进制 || oct() 转换为八进制 || hex() 转换为十六进制
ord() 将字符转换为对应的ASCII码值
chr() 将ASCII码值转换为对应的字符

数据结构

数据结构基本上是可以处理一些数据的结构。或者说，是用来存储一组相关数据的。在python中有四种内建的数据结构————列表、元组、字典和集合

列表

序列都可以进行的操作包括索引，切片，加，乘，检查成员。
列表是最常用的Python数据类型，它可以作为一个方括号内的逗号分隔值出现。

  1. 更新列表
    append()方法
  2. 删除列表元素
    del 语句

  3. 列表截取
    list[1:]

    1
    2
    3
    4
    5
    6
    7
    //创建一个列表，只要把逗号分隔的不同的数据项使用方括号括起来即可
    list=['one','two',3]  
    /end=""表示空格结束输出，而不是通常的换行
    print("these are:",list[0:2],end="") 
    list.sort()
    list.append('four') //给列表对象添加一项
    del list[0]   //用del语句将其移除

  4. 列表函数

    • cmp(list1,list2) 比较两个列表的元素
    • len(list) 列表元素个数
    • max(list) 返回列表元素最大值
    • min(list) 返回列表元素最小值
    • list(seq) 将元组转换为列表
  5. 方法
    • list.append() 在列表末尾添加新的对象
    • list.count() 统计某个元素在列表中出现的次数
    • list.extend() 在列表末尾一次性追加另一个序列中的多个值（用新列表扩展原来的列表）
    • list.index() 从列表中找出某个值第一个匹配项的索引位置
    • list.insert(index, obj) 将对象插入列表
    • list.pop() 移除列表中的一个元素（默认最后一个元素），并且返回该元素的值
    • list.remove() 移除列表中某个值的第一个匹配项
    • list.reverse() 反向列表元素
    • list.sort(cmp=None, key=None, reverse=False) 对原列表进行排序

元组

元组通常用在使语句或用户定义的函数能够安全地采用一组值的时候，即被使用的元组的值不会改变
zoo=(‘python1’,’python2’,’python3’)

元组和字符串一样，都是不可改变的，不能修改

但是可以使用del语句来删除整个元组，也可以对元组进行连接组合(tup3 = tup1 + tup2)

print(1,2,3)和print((1,2,3))意义不同 :
前一个打印三个数字，而后一个打印出一个元组(包含三个数)

内置函数:
tuple(seq) 将列表转换为元组。

字典

字典是dict类的实例/对象

字典类似于你通过联系人名字查找地址和联系人详细情况的地址簿，键必须是唯一的，就像如果有两个 人恰巧同名的话，你无法找到正确的信息。 记住字典中的键/值对是没有顺序的。如果你想要一个特定的顺序，那么你应该 在使用前自己对它们排序。

  1. 字典定义

    1
    2
    shuiguo={'apple':20,'banana':10,'orange':30}
    print(shuiguo['apple'])

  2. 字典的update

    1
    2
    3
    temp_list={"height":20}
    name_list.update(temp_list)
    //将temp的字典内容更新到name里，若是被合并的字典中包含已经存在的键值对时，原来的键值对会被覆盖。

  3. 删除和清空字典
    del name_list[‘banana’]

name_list.clear()//{}

集合

集合是没有顺序的简单对象的聚集。当在聚集中一个对象的存在 比其顺序或者出现的次数重要 时使用集合。
使用集合，可以检查是否是成员，是否是另一个集合的子集，得到两个集合的交集等等。

3

1
2
3
4
5
6
7
8
9
10
11
12
>>> bri = set(['brazil', 'russia', 'india'])
>>> 'india' in bri 
 True 
>>> 'usa' in bri 
 False 
>>> bric = bri.copy() 
>>> bric.add('china') 
>>> bric.issuperset(bri) //判断该方法的参数集合是否为指定集合的子集
True 
>>> bri.remove('russia') 
>>> bri & bric # OR bri.intersection(bric) 
 {'brazil', 'india'}
1
2
3
4
5
6
delimiter='__*__'
mylist = ['Brazil','Russia','India','China']
print(delimiter.join(mylist))//用字符把mylist中的字符连上Brazil__*__Russia__*__India__*__China
name='dawangwang'
if name.find('wan')!=-1://find用来找出指定字符串在另一个字符串中的位置，找不到返回-1
   print('Yes, it contains the string "wan"')

序列

列表，元组，字符串都是序列，序列是啥？
三种类型的序列 —— 列表、元组和字符串，也有切片操作，切片操 作让我们取出序列的薄片，例如序列的部分。

可以给切片规定第三个参数，就是切片的步长（默认步长是1）

当步长是 2 时，我们得到在位置 0,2,… 的项，当步长是 3 时，得到位置 0,3,

1
2
3
4
5
6
7
>>> mylist = ['Brazil','Russia','India','China']
>>> mylist[::1]
['Brazil', 'Russia', 'India', 'China']
>>> mylist[::2]
['Brazil', 'India']
>>> mylist[::3]
['Brazil', 'China']