人生苦短，我用Python

编译器：解释器编译器

Python属于解释型语言，读取一行，翻译一行，执行一行。

编译型语言执行快。

跨平台：编译型语言只能在一种操作系统，

解释型语言可以跨平台执行，只需要在各个操作系统中安装各自的解释器就行了。

Python是一门简单直观的语言

Python是开源的

Python代码阅读起来很容易

适用于短期开发的日常任务

Python开发哲学：

优雅，明确，简单

最好只用一种方法解决一个问题

拒绝花哨

为什么选择Python:

代码量少

面向对象，找别人，帮忙，，，这里对象就是别人

Python中函数，模块，字符串都是对象

Python拥有强大的标准局

Python社区提供了大量的第三方库，这里第三方库和标准局一样，只不过是由社区程序员提供。

可扩展性，一些关键算法不公开，用c或c++编写，然后在Python中使用他们

执行Python的三种方式：

解释器即在终端中

交互式 ipython

集成开发环境 Pycharm

Python源程序是简单的文本文件

文件扩展名为. py

在桌面建立一个文件夹，在建一个01. py文件，在这个目录下进入终端然后：

python 01.py Linux终端中执行python代码

^号表示到这里时代码出了问题，解释器无法解释

python每行代码完成一个动作。

syntax语法 invalid无效

indentation缩进

python2.*解释器不支持中文

python 01. py表示用python2执行

python3 01. py表示用python3执行

上面为解释器执行

cpython官方版本解释器

pypy python语言自己开发的解释器

交互式：终端中输入python或者python3

2**2 #2的2次方

交互式适合验证代码，学习小的代码

交互式下代码无法保存。

python的shell中输入exit()来退出shell或者用快捷键Ctrl + d来退出

非官网shell ipython支持自动补全，支持自动缩进支持输入Linux终端( bash shell)命令

在终端中输入ipython 或者ipython3进入这个shell

输入exit 来退出

IDE(集成开发环境)来执行python

pycharm

支持单步执行

pycharm适合开发大型项目

pycharm右上方执行的三角符号右边有个小虫子按钮，可以一步一步执行代码。在代码行号右边点击，会出现一个红色的断点。点击下方图片中鼠标所在的向下剪头来继续执行程序。

图片发自App

pycharm设置

Ubuntu中pycharm的配置信息保存在用户家目录下的 .pycharm***.*下 ***.*表示当前使用的pycharm版本

回复pycharm的初始设置:

关闭pycharm

ls -la

找到. pycharm***.*然后将其删除，就可以恢复初始设置了。

pycharm提供了对学生和教师免费使用的版本。下载地址如下：

图片发自App

建立一个项目，先建立一个目录。。。

项目就是解决复杂业务的软件

.idea 是记录项目相关内容

对于某个项目，设置其默认的解释器，到pycharm的File 下 setting 打开设置窗口来设置

建议：

命名时建议只使用小写字母，数字，下划线文件名不能以数字开头

项目示例：hm_01_知识点1

在file newproject 下建立项目，

然后建立

免费软件下载地址及安装教程：

图片发自App

第一次启动pycharm，想要运行项目，却无法运行，请看右下角进度条。走完才能运行。

对安装包解压缩后将包移动到/ opt目录下，方便其他用户使用。

设置pycharm快捷方式：先在终端打开pycharm，然后选择tools, 再选择Create Desktop Entry 之后再弹出的图标中需要勾选Create the entry for all user，输入密码后就可以使用了。

启动pycharm后会在家目录下建立一个. pycharm***.*这是pycharm配置信息。

下面的*pycharm. desktop 文件就是快捷方式，打开后会发现里面包含有图标以及启动的目录，启动目录正是pycharm. sh文件。

图片发自App

icon图标 Exec可执行文件

卸载pycharm只需要删除上图中的1 2 3三个文件即可。

在Ubuntu中，应用程序的快捷方式一般保存在/ usr/ share/ applications 目录下。

多文件项目的演练

为了保证注释整齐，#号后加个空格，如果好多文件没有加空格，点灯泡即可。

多行注释：

连续三个引号。

python官方建议文档

图片发自App

python运算符

图片发自App

"_" *10

----------

图片发自App

CPU负责干活，内存读取速度最快，硬盘转速越快，读取速度越快

程序安装在硬盘中，

常见内存条有4G 8G 16G 32G

硬盘一般比较大，有500G

图片发自App

QQ启动后，会在内存中划分出自己的区域。QQ密码账号也储运在内存中。类似QQ保存账号和密码，python定义变量储存也是在内存中。

数据类型：str字符型，int整型，bool布尔型，float浮点型

数据类型可以分为数字型和非数字型：

数字型：整型，浮点型，布尔型(非零即真)

非数字型：字符串，列表，元组，字典

type( )查看数据类型

不同类型的变量之间的运算：

布尔值在计算中代表0和1

两个字符串相加会将两个字符串连起来。

字符串*10 会吧字符串重复10次

函数是别人写好的代码，我们可以直接使用。

a=input("请输入")

input函数得到的变量都是str

类型转换：a= int( input("请输入")) #转换为整型

b= float( input("请输入")) #转换为浮点型

变量格式化输出：

print("我的名字叫%s " % "大明")

student=100

print ("我的学号是 %06d" % student)

输出结果将是000100，也就是不足6位0补齐

print("苹果单价 % f元/斤，购买了% f" %( price, weight))

%.2f表示只显示两位小数点

想继续输出%则需要再跟个%，如%%

print (数据比例是%.2f%% % x)

图片发自App

标识符，就是程序员定义的变量名，函数名，要能见知义，

标识符可以由字母，下划线，和数字组成

不能以数字开头

不能与关键字重名

关键字就是python内部已经占好的标识符

查看关键字：

import keyword

print (keword.kwlist)

标识符是区分大小写的。

变量命名规则：定义变量是为保证代码格式，=的左右应该各保留一个空格

如果表变量需要两个或多个单词时，可以按照以下方式命名：a.每个单词都小写

b.单词与单词之间使用_下划线连接

c.例如：first_name, last_name

驼峰命名firstName

if **:

条件成立后要做的事(四个空格)

# python开发时Tab和空格不要混用，要么只用tab要么只用空格。

Ctrl + f 剪切 Ctrl+ v粘贴

!= 检查是否不相等

if *** :

…

else :

…

选中要注释的文本，按住Ctrl键按下/来注释更多文本。

if和else

逻辑运算：and且 or或 not非

is_employee= True

if not is_employee:

print("非本公司员工，请勿入内")

if 语句进阶 elif

if 条件1：

…

elif 条件2：

…

elif 条件3

…

else:

…

==判断是否相等

if嵌套

注意缩进4个空格

选中一大段代码，然后按一下tab 按shift+ tab来取消缩进。

has_ticket= True

if has_ticket

break 退出循环

i=0

while i<10:

if i==3:

break

print( i)

i+=1

continue某一条件满足时，不执行循环的后续代码，继续到条件判断进行循环。

i=0

while i<10:

if i==3:

i=4 #如果没有这条语句，就会进入死循环，使用continue时一定要注意。

continue

print(i)

i+=1

循环嵌套

在控制台连续输出*，每行*数量依次递增

row=1

while row<=5:

print("*"* row)

row+=1

print("*" end="") #不换行end="---"则用---连接

print("*")

使用循环嵌套打印小星星

row =1

while row<=5:

col=1

while col<= row:

print("*", end="") #不换行

col+=1

print("") #换行

row+=1

函数的创建和引用

>>> def add(x,y): #创建一个名为add的函数

... print "x=",x #分别打印参数赋值结果

... print "y=",y

... return x+y

...

>>> add(10,3) #x=10,y=3#调用函数

x= 10

y= 3

>>> add(3,10) #x=3,y=10

x= 3

y= 10

>>> def times(x,y=2): #y的默认值为2

... print "x=",x

... print "y=",y

... return x*y

...

>>> times(3) #x=3,y=2

x= 3

y= 2

>>> times(x=3) #同上

x= 3

y= 2

交互模式下输入hlep()进入联机帮助状态

按q返回

>>>help( modules) #查看可用模块( Python自带电池，模块就是电池)

print("%d X %d=%d" (a,b,c))

转义字符\t 输出时使垂直方向对齐

print("1\t2\t\t3")

print("10\t20\t30\t")

\nn

print( "hellohello\" hello ")

print( "hello \n Python") 使输出换行

封装一个包，需要时直接调用。

def abc(): 定义一个函数

"""函数注释"""

*…

*… #函数内容

在函数定义的位置按CTRL+ Q查看

import hm_01_九九乘法表 #代码文件名称

hm_01_九九乘法表.abc() #调用函数

定义好函数之后，只表示这个函数封装了一段代码，想要运行需要调用

def say_hello():

print(" hello")

say_hello() #必须这样调用，函数才会执行。一般还需要import，但这里不用，因为函数本来就在这里的文件中。

函数不会被执行，只有调用了才会被执行。

f8断点执行

def sum_2_num( num1, num2) #形参

"""对两个数字求和"""

result= num1+ num2

print("%d +%d =%d " %( num1, num2, result)

sum_2_num(10,30) #调用函数，这里10和30叫实参

函数能被调用，需要和代码在同一个文件夹下

函数返回值。调用一方，使用变量来获取返回结果。

def sum_2_num(num1, num2)

result= num1+num2

return result #函数执行到return就会返回到原代码

sum_result=sum_2_num(10,20)

函数的嵌套调用

def print_line(char，times)

print( char * times)

print_line("-",40) #任意字符打印任意次数的分隔线

工作中遇到新的变化，不要急着改函数

def print_lines(x, y)

row=0

while row<5:

print_line(x,y) #调用上面的函数

row+=1

print_lines("~",40)

-----------------------------------------

>>> help()

help> keywords

按q从文档说明文档返回

>>>help(modules)

help("math") #如果在>help下只需要输math

使用dir()函数来查看模块及其他对象的内容

>>> import keyword

>>> dir(keyword)

-----------------/------------------

if __name__ == "__main__": #这句代码的意思是如果模块不是被导入的话就运行，是在其他模块而被导入则不运行。

运行Python程序的两种方式

python xxx.py，直接运行xxx.py文件

python -m xxx.py，把xxx.py当做模块运行

直接运行方式是把run.py文件所在的目录放到了sys.path属性中

以模块方式运行是把你输入命令的目录（也就是当前工作路径），放到了 sys.path 属性中

>>> def my_fun():

... print "I am coding."

... return

... print "I finished."

...

>>> my_fun()

I am coding.

在函数中，本来有两个print语句，但是中间插入了一个return，仅仅是一个return。当执行函数的时候，只执行了第一个print语句，第二个并没有执行。这是因为第一个之后，遇到了return，它告诉函数要返回，即中断函数体内的流程，离开这个函数。结果第二个print就没有被执行。所以，return在这里就有了一个作用，结束正在执行的函数，有点类似循环中的break的作用。

_doc_中的内容即为函数的文档，函数名称下面，用三个双引号包裹的，就是_doc_

>>> def my_fun():

... """

... This is my function.

... """

... print "I am a craft."

...

>>> my_fun.__doc__

'\n This is my function.\n

python的内建函数（built-in function）。关于python的内建函数，下面都列出来了。所谓内建函数，就是能够在python中直接调用，不需要做其它的操作。

Built-in Functions

|all() | enumerate() | int() | ord() | str()|

|any() | eval() | isinstance()| pow()| sum()|

|cmp() | globals()| max()| reversed()| zip()|

|dir() | id() |oct() |sorted() |intern()|

用help( raw_input)在交互模式下来查看函数的作用。还可以去Python官网

字符串，索引

>>> lang = "study python"

>>> lang[0]

's'

>>> "study python"[0]

's'

>>> lang.index("p")

>>> lang[2:9]

'udy pyt'

>>> lang

'study python'

>>> b = lang[1:] #得到从1号到最末尾的字符，这时最后那个需要不用写

>>> b

'tudy python'

>>> c = lang[:] #得到所有字符

>>> c

'study python'

>>> d = lang[:10] #得到从第一个到10号之前的字符

>>> d

'study pyth'

c=lang[:]

>>> id(c)

3071934536L

>>> id(lang)

3071934536L #没有复制一份，而是新贴了一个标签

字符串是一种序列，所有序列都有如下基本操作：

len()：求序列长度

· ：连接2个序列

· : 重复序列元素

in :判断元素是否存在于序列中

max() :返回最大值

min() :返回最小值

cmp(str1,str2) :比较2个序列值是否相同

>>> "a" in str1

True

>>> "de" in str1

False

>>> "de" in str2

True

>>> max(str1)

'd'

>>> cmp(str1, str2)

-1

>>> ord('a') #ord()是一个内建函数，能够返回某个字符（注意，是一个字符，不是多个字符组成的串）所对一个的ASCII值（是十进制的）

>>> chr(97) #由ASCII得到对应的字符

'a'

>>> cmp("a","b") #a-->97, b-->98, 97小于98，所以a小于b

-1

--------------------

>>> a = "hello"

>>> len(a)

---------------------

>>> "I like %s" % "python"

'I like python'

>>> "I like %s" % "Pascal"

'I like Pascal'

常用占位符 %d %s %f

如下为所有占位符：

占位符

%s 字符串(采用str()的显示)

%r 字符串(采用repr()的显示)

%c 单个字符

%b 二进制整数

%d 十进制整数

%i 十进制整数

%o 八进制整数

%x 十六进制整数

%e 指数 (基底写为e)

%E 指数 (基底写为E)

%f 浮点数

%F 浮点数，与上相同

%g 指数(e)或浮点数 (根据显示长度)

%G 指数(E)或浮点数 (根据显示长度)

>>> print "Suzhou is more than %d years. %s lives in here." % (2500, "qiwsir")

Suzhou is more than 2500 years. qiwsir lives in here.

以下方法更加方便：

>>> s1 = "I like {0}".format("python")

>>> s1

'I like python'

>>> s2 = "Suzhou is more than {0} years. {1} lives in here.".format(2500, "qiwsir")

>>> s2

'Suzhou is more than 2500 years. qiwsir lives in here.'

>>> dir(str) #这个貌似是查看字符串或者其他对象的一些性质吧，例如_doc_是说明文档

['__add__', '__class__', '__contains__', '__delattr__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__getnewargs__', '__getslice__', '__gt__', '__hash__', '__init__', '__le__', '__len__', '__lt__', '__mod__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__rmod__', '__rmul__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '_formatter_field_name_split', '_formatter_parser', 'capitalize', 'center', 'count', 'decode', 'encode', 'endswith', 'expandtabs', 'find', 'format', 'index', 'isalnum', 'isalpha', 'isdigit', 'islower', 'isspace', 'istitle', 'isupper', 'join', 'ljust', 'lower', 'lstrip', 'partition', 'replace', 'rfind', 'rindex', 'rjust', 'rpartition', 'rsplit', 'rstrip', 'split', 'splitlines', 'startswith', 'strip', 'swapcase', 'title', 'translate', 'upper', 'zfill

>>> help(str.isalpha) #用help()来查看以上每个的说明

Help on method_descriptor:

isalpha(...)

S.isalpha() -> bool

Return True if all characters in S are alphabetic

and there is at least one character in S, False otherwise.

--------------------------------

>>> "python".isalpha() #字符串全是字母，应该返回True

True

>>> "2python".isalpha() #字符串含非字母，返回False

False

>>> a = "I LOVE PYTHON"

>>> a.split(" ") #根据某个分割符进行分割。

['I', 'LOVE', 'PYTHON'] #得到一个叫做列表( list)的返回值

>>> b = "www.itdiffer.com"

>>> b.split(".")

['www', 'itdiffer', 'com']

------------------

>>> b=" hello " #两边有空格

>>> b.strip() # b并不会变化，而是会返回一个新值，可以用a=b.strip()把新值装起来

'hello'

>>> b

' hello '

>>> b.lstrip() #去掉左边的空格

'hello '

>>> b.rstrip() #去掉右边的空格

' hello'

S.upper() #S中的字母大写

S.lower() #S中的字母小写

S.capitalize() #首字母大写

S.isupper() #S中的字母是否全是大写

S.islower() #S中的字母是否全是小写

S.istitle() #S中字符串中所有的单词拼写首字母是否为大写，且其他字母为小写

>>> b

'www.itdiffer.com'

>>> c = b.split(".")

>>> c

['www', 'itdiffer', 'com']

>>> ".".join(c)

'www.itdiffer.com'

>>> "*".join(c)

'www*itdiffer*com'

---------------------

list在Python中拥有非常强大的功能

>>> a=[] #定义了一个变量a，它是list类型，并且是空的。

>>> type(a)

#用内置函数type()查看变量a的类型，为list

>>> bool(a) #用内置函数bool()看看list类型的变量a的布尔值，因为是空的，所以为False

False

>>> print a #打印list类型的变量a

[]

>>> a=['2',3,'qiwsir.github.io']

>>> a

['2', 3, 'qiwsir.github.io']

>>> type(a)

>>> bool(a)

True

>>> print a

['2', 3, 'qiwsir.github.io']

>>> a

['2', 3, 'qiwsir.github.io']

>>> a[0] #索引序号也是从0开始

'2'

>>> a[1]

>>> [2]

[2]

>>> a[:2] #跟str中的类似，切片的范围是：包含开始位置，到结束位置之前

['2', 3] #不包含结束位置

>>> a[1:]

[3, 'qiwsir.github.io']

>>> a[2][7:13] #可以对列表元素做2次切片

'github'

这里和前面的索引有相似

list和str两种类型的数据，有共同的地方，它们都属于序列（都是一些对象按照某个次序排列起来，这就是序列的最大特征），因此，就有很多类似的地方。如刚才演示的索引和切片，是非常一致的。

>>> lang = "python"

>>> lang.index("y")

>>> lst = ['python','java','c++']

>>> lst.index('java')

>>> alst = [1,2,3,4,5,6]

>>> alst[::-1] #反转

[6, 5, 4, 3, 2, 1]

>>> alst

[1, 2, 3, 4, 5, 6]

字符串也可以反转

>>> lang

'python'

>>> lang[::-1]

'nohtyp'

>>> lang

'python'

>>> list(reversed(alst)) #另外一种反转list的方法

[6, 5, 4, 3, 2, 1]

>>> list(reversed("abcd"))

['d', 'c', 'b', 'a']

>>> lst

['python', 'java', 'c++']

>>> alst

[1, 2, 3, 4, 5, 6]

>>> lst + alst

['python', 'java', 'c++', 1, 2, 3, 4, 5, 6]

>>> "python" in lst

True

>>> "c#" in lst

False

追加元素

>>> a = ["good","python","I"]

>>> a

['good', 'python', 'I']

>>> a.append("like") #向list中添加str类型"like"

>>> a

['good', 'python', 'I', 'like']

>>> a.append(100) #向list中添加int类型100

>>> a

['good', 'python', 'I', 'like', 100]

，，，，，另一种

追加方法如下

>>> a

['good', 'python', 'I', 'like', 100]

>>> a[len(a):]=[3] #len(a),即得到list的长度，这个长度是指list中的元素个数。

>>> a

['good', 'python', 'I', 'like', 100, 3]

>>> len(a)

>>> a[6:]=['xxoo']

>>> a

['good', 'python', 'I', 'like', 100, 3, 'xxoo']

两个list可以合并，如下：

>>> la

[1, 2, 3]

>>> lb

['qiwsir', 'python']

>>> la.extend(lb)

>>> la

[1, 2, 3, 'qiwsir', 'python']

>>> lb

['qiwsir', 'python']

>>> la = [1,2,3]

>>> b = "abc"

>>> la.extend(b)

>>> la

[1, 2, 3, 'a', 'b', 'c']

>>> c = 5

>>> la.extend(c)

Traceback (most recent call last):

File "", line 1, in

TypeError: 'int' object is not iterable

如果extend(str)的时候，str被以字符为单位拆开，然后追加到la里面。如果extend的对象是数值型，则报错。

>>> astr = "python"

>>> hasattr(astr,'__iter__')

False

>>> new = [1,2,3]

>>> lst = ['python','qiwsir']

>>> lst.extend(new)

>>> lst

['python', 'qiwsir', 1, 2, 3]

>>> new

[1, 2, 3]

>>> one = ["good","good","study"]

>>> another = one.extend(["day","day","up"]) #对于没有提供返回值的函数，如果要这样，结果是：

>>> another #这样的，什么也没有得到。

>>> one

['good', 'good', 'study', 'day', 'day', 'up']

>>> la = [1,2,1,1,3]

>>> la.count(1)

>>> la.append('a')

>>> la

[1, 2, 1, 1, 3, 'a', 'a']

>>> la.count('a')

>>> la.count(2)

>>> la.count(5) #NOTE:la中没有5,但是如果用这种方法找，不报错，返回的是数字0

>>> la

[1, 2, 3, 'a', 'b', 'c', 'qiwsir', 'python']

>>> la.index(3)

>>> la.index('qi') #如果不存在，就报错

Traceback (most recent call last):

File "", line 1, in

ValueError: 'qi' is not in list

>>> la.index('qiwsir')

列表的方法有：'append', 'count', 'extend', 'index', 'insert', 'pop', 'remove', 'reverse', 'sort'

与list.append(x)类似，list.insert(i,x)也是对list元素的增加。只不过是可以在任何位置增加一个元素。

>>> all_users.insert(0,"python")

>>> all_users

['python', 'qiwsir', 'github', 'io']

>>> all_users.insert(1,"http://")

>>> all_users

['python', 'http://', 'qiwsir', 'github', 'io']

>>> length = len(all_users)

>>> length

>>> all_users.insert(length,"algorithm")

>>> all_users

['python', 'http://', 'qiwsir', 'github', 'io', 'algorithm']

这里如果超过最大索引值，就会自动添加到末尾。

--------------------------

list.remove()

list.pop([i])

>>> "python" in all_users #这里用in来判断一个元素是否在list中，在则返回True，否则返回False

True

>>> a = [3,5,1,6]

>>> a.reverse()

>>> a

[6, 1, 5, 3

list.sort()也是让列表进行原地修改，没有返回值。默认情况，如上面操作，实现的是从小到大的排序。

>>> a.sort(reverse=True)

>>> a

[6, 5, 3, 1]

>>> lst = ["python","java","c","pascal","basic"]

>>> lst.sort(key=len)

>>> lst

['c', 'java', 'basic', 'python', 'pascal']

这是以字符串的长度为关键词进行排序。

>>> welcome_str = "Welcome you"

>>> welcome_str[0]

'W'

>>> welcome_str[1]

'e'

>>> welcome_str[len(welcome_str)-1]

'u'

>>> welcome_str[:4]

'Welc'

>>> a = "python"

>>> a*3

'pythonpythonpython'

>>> git_list = ["qiwsir","github","io"]

>>> git_list[0]

'qiwsir'

>>> git_list[len(git_list)-1]

'io'

>>> git_list[0:2]

['qiwsir', 'github']

>>> b = ['qiwsir']

>>> b*7

['qiwsir', 'qiwsir', 'qiwsir', 'qiwsir', 'qiwsir', 'qiwsir', 'qiwsir']

>>> first = "hello,world"

>>> welcome_str

'Welcome you'

>>> first+","+welcome_str #用+号连接str

'hello,world,Welcome you'

>>> welcome_str #原来的str没有受到影响，即上面的+号连接后重新生成了一个字符串

'Welcome you'

>>> first

'hello,world'

>>> language = ['python']

>>> git_list

['qiwsir', 'github', 'io']

>>> language + git_list #用+号连接list，得到一个新的list

['python', 'qiwsir', 'github', 'io']

>>> git_list

['qiwsir', 'github', 'io']

>>> language

['python']

>>> len(welcome_str) #得到字符数

>>> len(git_list) #得到元素数

>>> git_list

['qiwsir', 'github', 'io']

>>> git_list.append("python")

>>> git_list

['qiwsir', 'github', 'io', 'python']

>>> git_list[1]

'github'

>>> git_list[1] = 'github.com'

>>> git_list

['qiwsir', 'github.com', 'io', 'python']

>>> git_list.insert(1,"algorithm")

>>> git_list

['qiwsir', 'algorithm', 'github.com', 'io', 'python']

>>> git_list.pop()

'python'

>>> del git_list[1]

>>> git_list

['qiwsir', 'github.com', 'io']

>>> welcome_str

'Welcome you'

>>> welcome_str[0]+"E"+welcome_str[2:] #从新生成一个str

'WElcome you'

>>> welcome_str #对原来的没有任何影响

'Welcome you'

>>> matrix = [[1,2,3],[4,5,6],[7,8,9]]

>>> matrix[0][1]

>>> mult = [[1,2,3],['a','b','c'],'d','e']

>>> mult

[[1, 2, 3], ['a', 'b', 'c'], 'd', 'e']

>>> mult[1][1]

'b'

>>> mult[2]

'd'

>>> line = "Hello.I am qiwsir.Welcome you."

>>> line.split(".") #以英文的句点为分隔符，得到list

['Hello', 'I am qiwsir', 'Welcome you', '']

>>> line.split(".",1) #这个1,就是表达了上文中的：If maxsplit is given, at most maxsplit splits are done.

['Hello', 'I am qiwsir.Welcome you.']

>>> name = "Albert Ainstain" #也有可能用空格来做为分隔符

>>> name.split(" ")

['Albert', 'Ainstain']

>>> s = "I am, writing\npython\tbook on line" #这个字符串中有空格，逗号，换行\n，tab缩进\t 符号

>>> print s #输出之后的样式

I am, writing

python book on line

>>> s.split() #用split(),但是括号中不输入任何参数

['I', 'am,', 'writing', 'python', 'book', 'on', 'line']

如果split()不输入任何参数，显示就是见到任何分割符号，就用其分割了。

>>> name

['Albert', 'Ainstain']

>>> "".join(name) #将list中的元素连接起来，但是没有连接符，表示一个一个紧邻着

'AlbertAinstain'

>>> ".".join(name) #以英文的句点做为连接分隔符

'Albert.Ainstain'

>>> " ".join(name) #以空格做为连接的分隔符

'Albert Ainstain'

>>> s = "I am, writing\npython\tbook on line"

>>> print s

I am, writing

python book on line

>>> s.split()

['I', 'am,', 'writing', 'python', 'book', 'on', 'line']

>>> " ".join(s.split()) #重新连接，不过有一点遗憾，am后面逗号还是有的。怎么去掉？

'I am, writing python book on line'

对于函数，缺省参数就是如果不输入值就使用默认值。如：def lan(a, b=10) 这里lan函数的b参数就是缺省参数，如果引用函数时不对b赋值，则会自动为其赋值10，缺省参数需要在函数声名时放在一般参数的后面。

函数中，*arg 可以作为输入元组的参数， ** arg可以作为输入字典的参数。有时需要输入元组和字典，引用函数时可能所有输入值都被* arg得到，例如：lan (a,b) a为元组，d为字典，我们的本意是让a进入* arg，而b进入**arg ，但结果会是a,b均进入元组 * arg。解决办法是：lan(*a ,**b) 这个叫做拆包

写一个编程之禅：：想要实现某个功能，应该先从大体框架出发，不要一开始就从头开始想代码。比如要开发一个多项混合运算，可以先声明函数，把需要的参数带上，再把最后需要显示的参数，打印出来。构建这样一个整体的框架，然后开始从内部开始入手，想想是否需要一些模块来完成整个过程，也就是分步，或者把一些功能以模块的形式写出来，在主模块只需要引用一下。

面向过程：

面相对象：

类：相当于制造飞机的图纸

对象：相当于零件。

Python笔记

if 语句进阶 elif

循环嵌套

函数的创建和引用

运行Python程序的两种方式

占位符

list在Python中拥有非常强大的功能

列表的方法有：'append', 'count', 'extend', 'index', 'insert', 'pop', 'remove', 'reverse', 'sort'

你可能感兴趣的:(Python笔记)