python学习笔记_python学习笔记完整 - CSDN
精华内容
参与话题
  • python 学习笔记(超详细)(一)

    千次阅读 2019-02-07 10:59:23
    文章目录python 学习笔记(一)1.python内存管理方式2.数字3.字符串4.运算符与表达式5.常用内置函数6.对象的删除(好习惯)7.基本的输入输出8.模块的导入与使用9.python之禅--The Zen of Python python 学习笔记(一...

    python 学习笔记(一)

    1.python内存管理方式

    print(isinstance(3,int))
    x=3
    print(id(x))
    y=3
    x=x+6
    print(id(y))
    print(id(x))
    

    True
    1826254368
    1826254368
    1826254560

    • 在python中修改变量值的操作,并不是修改了变量的数值,而是修改了变量指向的内存地址。
    • 首先读取x的值,然后加6,并将结果存放于内存中,最后将x指向该内存空间。
    • python采用的是基于值的内存管理方式,如果为不同的变量赋值为相同值,则这个值在内存中只有一份,多个变量指向同一内存。
    • python具有自动管理内存的功能,对于没有任何变量指向的值,python将其自动删除。

    2.数字

    a=99999999999999
    print(a*a)
    print(math.sqrt(3**2+4**2))
    a=3+4j
    b=complex(5,6)
    c=a+b
    print(c)
    print(c.real)
    print(c.imag)
    print(c.conjugate())
    

    9999999999999800000000000001
    5.0
    (8+10j)
    8.0
    10.0
    (8-10j)

    • python中数字类型的变量可以表示任意大的数值
    • 十六进制一0x开头,八进制以0o开头,二进制以0b开头
    • python中可以表示复数用j来表示虚部complex(a,b)函数可以形成复数
    • real查看实部 imag查看虚部 conjugate()返回共轭复数

    3.字符串

    a='abc'+'123'
    b=3.6674
    print(a)
    print(a*2)
    print('%7.3f'%b)
    print('%d:%c'%(65,65))
    print(a[-1])
    print(a[0:3])
    

    abc123
    abc123abc123
    3.667
    65:A
    3
    abc

    • 在python中字符串属于不可变序列,可以用单引号、双引号、三引号界定,并且三者可以相互嵌套
    • 空字符串可表示为’ ‘或’’ ‘‘或’’’ ‘’’
    • 字符串支持+ * 运算进行合并生成新字符串
    • python支持字符串按从右-1编号,也可以切片
      a[0:3]表示从下表为0到2 (3-1)
    • a[ start:end]
      start和end都是整数型数值,这个子序列从索引start开始直到索引end结束,但不包括end位置。
      在这里插入图片描述
    print("{}{}{}".format("圆周率是","3.1415926","..."))
    print("{1}:{2}:{0}".format("123","abc","wd"))
    print("{0:-^20.7}".format("123"))
    

    圆周率是3.1415926…
    abc:wd:123
    --------123--------

    • 字符串format()方法的基本使用格式是:
      <模板字符串>.format(<逗号分隔的参数>)
    • format()方法中模板字符串的槽除了包括参数序号,还可以包括格式控制信息

    在这里插入图片描述

    4.运算符与表达式

    在这里插入图片描述

    print("2/3=",2/3)
    print("3//2=",3//2)
    print("2**3=",2**3)
    print("3.0//3.0=",3.0//2.0)
    print(2>=3)
    print(3>=2)
    print(2!=2)
    print(10 and 25)
    print(0 or 20)
    print(not 10)
    

    2/3= 0.6666666666666666
    3//2= 1
    2**3= 8
    3.0//3.0= 1.0
    False
    True
    False
    25
    20
    False

    • x or y 只有x为假的才计算y
    • x and y 只有x为真才计算y
    • 大小比较可以连用 x>=y x<=y
    print('a' in 'b','a')
    print('a' in ('b','a'))
    x=3,5
    print(x)
    print(3==3,5)
    x=3+5,7
    print(x)
    

    False a
    True
    (3, 5)
    True 5
    (8, 7)

    • python中逗号 , 并不是运算符,而只是一个普通的分隔符

    5.常用内置函数

     >>>dir(__builtins__)
    ['__class__', '__contains__', '__delattr__', '__delitem__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__iter__', '__le__', '__len__', '__lt__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__setitem__', '__sizeof__', '__str__', '__subclasshook__', 'clear', 'copy', 'fromkeys', 'get', 'items', 'keys', 'pop', 'popitem', 'setdefault', 'update', 'values']
    
    • 执行这个命令可以查看所有内置函数和内置对象(两个下划线)
    a=-2
    b=[1,2,3,4,0]
    c='a'
    print(  abs(a)  ) #返回数字的绝对值
    print(  all(b)  ) #对于可迭代对象所有元素 全部非零返回true 若存在零返回false
    print(  any(b)  ) #对于可迭代对象存在元素非零,则返回true
    print(  bin(a)  ) #把数字转换为二进制串
    print(  callable(a) ) #测试对象是否可调用,类和函数是可调用的
    print(  chr(65) ) #返回ASCII编码的字符
    #print(  dir(a)  ) #返回指定对象的成员列表
    print(  ord(c)  ) #返回一个字符的编码
    print(  str(b)  ) #把对象转化为字符串
    print(  help(math.sin)) #查看指定方法的使用帮助
    print(  list(b) )# 把对象转换为 列表
    print(  set(b)  ) #集合
    print(  tuple(b) )# 元组
    #print(  dict(b) ) #字典并返回
    

    2
    False
    True
    -0b10
    False
    A
    97
    [1, 2, 3, 4, 0]
    Help on built-in function sin in module math:
    sin(…)
    sin(x)
    Return the sine of x (measured in radians).
    None
    [1, 2, 3, 4, 0]
    {0, 1, 2, 3, 4}
    (1, 2, 3, 4, 0)

    6.对象的删除(好习惯)

    x=[1,2,3,4,5]
    y=3
    print(y)
    del y
    del x[1]
    print(x)
    print(y)
    

    3
    [1, 3, 4, 5]
    Traceback (most recent call last):
    File “E:/robocup/python/练习.py”, line 11, in
    print(y)
    NameError: name ‘y’ is not defined

    • del命令可以显示删除并解除值之间的指向关系,如果变量指向的值还有别的变量指向,则不删除该值。
    • del可以删除列表中指定元素,也可以删除整个列表
    • del无法删除元组或字符串中的指定元素,只能删除整个字符串(两者属于不可变序列)

    7.基本的输入输出

    x=input("please input:")
    print(type(x))
    print(x,end=" ")
    print(int(x)+1)
    

    please input:6
    <class ‘str’>
    6 7

    • 在python中,使用内置函数input()来接收用户的键盘输入,括号内可以添加提示字符串
    • python3中输入的统一默认为字符串,如果需要改变变量需要用强制转换
    • python3中输出要加括号并且自动换行,如果不需要换行,则加上end=“ ”
    fp=open('E:\\robocup\\python\\python.txt','a+')
    print('hello,world!',file=fp)
    fp.close()
    
    • python在指定文件中输出,用文件的方法,先打开文件(注意路径用\ \ 第一个是转义字符),然后输出,最后关闭文件

    8.模块的导入与使用

    import math
    from math import sin as f
    
    print(math.sin(3))
    print(f(3))
    

    0.1411200080598672
    0.1411200080598672

    • python中有大量第三方库可用“pip install 。。。”进行有需要的安装
    • 在使用库函数时,需要导入,有两种方法:1. import 模块名【as 别名】
      使用这种方式导入后,需要在使用的对象前加上前缀 “模块名 . 对项名”的方式进行访问,也可以用“别名 . 对象名”的方式使用其中的对象
      2.from 模块名 import 对象名【as 别名】
      使用这种方式仅导入使用的对象,并且可以为这个对象起一个别名,这种方法可以减少查询次数,减少程序员的代码量,不需要使用模块名作为前缀
    • 比较极端的情况是一次导入模块中全部的对象
      from math import *
      不推荐使用这中方法,一旦多个模块中有同名的对象,会导致混乱

    9.python之禅–The Zen of Python

    import this
    ```python
    >输入import this 即可得到一篇美文,多体会这段话,努力让自己的代码更优雅
    >The Zen of Python, by Tim Peters
    
    Beautiful is better than ugly.
    Explicit is better than implicit.
    Simple is better than complex.
    Complex is better than complicated.
    Flat is better than nested.
    Sparse is better than dense.
    Readability counts.
    Special cases aren't special enough to break the rules.
    Although practicality beats purity.
    Errors should never pass silently.
    Unless explicitly silenced.
    In the face of ambiguity, refuse the temptation to guess.
    There should be one-- and preferably only one --obvious way to do it.
    Although that way may not be obvious at first unless you're Dutch.
    Now is better than never.
    Although never is often better than *right* now.
    If the implementation is hard to explain, it's a bad idea.
    If the implementation is easy to explain, it may be a good idea.
    Namespaces are one honking great idea -- let's do more of those!
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    展开全文
  • Python基础学习笔记之(一)

    万次阅读 多人点赞 2014-02-22 11:14:24
    Python基础学习笔记之(一)zouxy09@qq.comhttp://blog.csdn.net/zouxy09 前段时间参加微软的windowsAzure云计算的一个小培训,其中Python被用的还是蛮多的。另外,一些大公司如Google(实现web爬虫和搜索引擎中的...

    Python基础学习笔记之(一)

    zouxy09@qq.com

    http://blog.csdn.net/zouxy09

     

           前段时间参加微软的windows Azure云计算的一个小培训,其中Python被用的还是蛮多的。另外,一些大公司如Google(实现web爬虫和搜索引擎中的很多组件),Yahoo(管理讨论组),NASA,YouTube(视频分享服务大部分由Python编写)等等对Python都很青睐。而国内的豆瓣可以说是给Python予千万宠爱了,它的前台后台清一色的都是Python的身影。另外,我们计算机视觉这块用的很频繁的OpenCV也提供了Python的接口,网上还提供了不少Python的机器学习的库(例如milkscikit-learnPylearn2等),Deep learning的一个知名的Python的库theano,自然语言处理的库NLTK。此外,Python为数学、科学、工程和绘图等提供了有趣的标准库(例如,NumPy ,SciPy和matplotlib等),这使得一部分Matlab的使用者慢慢的倒戈到Python阵营,没办法,谁叫Matlab贵呢!当然了,Python不仅是免费,它还具有Matlab较弱或者没有的一些其他的功能,例如文件管理、界面设计、网络通信等。这就使得Python占有的用户群更广。

           Python是“蟒蛇”的意思,这个名字是有点故事的。当然了,这个得追溯到它的发明者Guido van Rossum。在1989年圣诞节期间,Guido身处阿姆斯特丹。这个都市的美丽和繁华没能填满Guido空虚的内心,周边的喧闹使他内心的寂寞无处安放(夜的黑已不再纯粹,哈哈)。为了打发这种无趣,Guido决心为他之前孕育的ABC语言开发一个插件,这个插件就是大名鼎鼎的Python(男人因为孤独而优秀啊!)。一个新的脚本解释程序就此诞生。在给这个孩子起名字的时候,Guido取其所爱的一个叫Monty Python的喜剧团体的“Python”。

           官方点说,Python是一种解释型、面向对象、动态数据类型的高级程序设计语言。Python语法简洁而清晰,具有丰富和强大的类库。它常被昵称为胶水语言,它能够很轻松的把用其他语言制作的各种模块(尤其是C/C++)轻松地联结在一起。自从20世纪90年代初Python语言诞生至今,它逐渐被广泛应用于处理系统管理任务和Web编程。Python已经成为最受欢迎的程序设计语言之一。2011年1月,它被TIOBE编程语言排行榜评为2010年度语言。自从2004年以后,python的使用率是呈线性增长。

           这篇博文是我看了“中谷教育-Python视频教程”的一个笔记,记录的是一些Python的学习基础,整理到这里,一是总结,二是备查。网上也有比较好的教程,例如“Python 精要参考”。

     

    目录

    一、安装、编译与运行

    二、变量、运算与表达式

    三、数据类型

          1、数字

          2、字符串

          3、元组

          4、列表

          5、字典

    四、流程控制

          1、if-else

          2、for

          3、while

          4、switch

    五、函数

          1、自定义函数

          2、Lambda函数

          3、Python内置函数

    六、包与模块

          1、模块module

          2、包package

    七、正则表达式

          1、元字符

          2、常用函数

          3、分组 

          4、一个小实例-爬虫

    八、深拷贝与浅拷贝

    九、文件与目录

          1、文件读写

          2、OS模块

          3、目录遍历

    十、异常处理

     

    一、安装、编译与运行

           Python的安装很容易,直接到官网:http://www.python.org/下载安装就可以了。Ubuntu一般都预安装了。没有的话,就可以#apt-get install python。Windows的话直接下载msi包安装即可。Python 程序是通过解释器执行的,所以安装后,可以看到Python提供了两个解析器,一个是IDLE (Python GUI),一个是Python (command line)。前者是一个带GUI界面的版本,后者实际上和在命令提示符下运行python是一样的。运行解释器后,就会有一个命令提示符>>>,在提示符后键入你的程序语句,键入的语句将会立即执行。就像Matlab一样。

           另外,Matlab有.m的脚步文件,python也有.py后缀的脚本文件,这个文件除了可以解释执行外,还可以编译运行,编译后运行速度要比解释运行要快。

           例如,我要打印一个helloWorld。

    方法1:直接在解释器中,>>> print ‘helloWorld’。

    方法2:将这句代码写到一个文件中,例如hello.py。运行这个文件有三种方式:

    1)在终端中:python hello.py

    2)先编译成.pyc文件:

    import py_compile

    py_compile.compile("hello.py")

    再在终端中:python hello.pyc

    3)在终端中:

    python -O -m py_compile hello.py

    python hello.pyo

           编译成.pyc和.pyo文件后,执行的速度会更快。所以一般一些重复性并多次调用的代码会被编译成这两种可执行的方式来待调用。

     

    二、变量、运算与表达式

             这里没什么好说的,有其他语言的编程基础的话都没什么问题。和Matlab的相似度比较大。这块差别不是很大。具体如下:

             需要注意的一个是:5/2 等于2,5.0/2才等于2.5。

    ###################################
    ### compute #######
    # raw_input() get input from keyboard to string type
    # So we should transfer to int type
    # Some new support computing type:
    # and or not in is < <= != == | ^ & << + - / % ~ **
    print 'Please input a number:'
    number = int(raw_input()) 
    number += 1
    print number**2 # ** means ^
    print number and 1
    print number or 1
    print not number
    5/2 # is 2
    5.0/2 # is 2.5, should be noted
    

    三、数据类型

    1、数字

             通常的int, long,float,long等等都被支持。而且会看你的具体数字来定义变量的类型。如下:

    ###################################
    ### type of value #######
    # int, long, float
    # do not need to define the type of value, python will
    # do this according to your value
    num = 1   # stored as int type
    num = 1111111111111   # stored as long int type
    num = 1.0   # stored as float type
    num = 12L # L stands for long type
    num = 1 + 12j # j stands for complex type
    num = '1' # string type
    

    2、字符串

             单引号,双引号和三引号都可以用来定义字符串。三引号可以定义特别格式的字符串。字符串作为一种序列类型,支持像Matlab一样的索引访问和切片访问。

    ###################################
    ### type of string #######
    num = "1" # string type
    num = "Let's go" # string type
    num = "He's \"old\"" # string type
    mail = "Xiaoyi: \n hello \n I am you!"
    mail = """Xiaoyi:
    	hello
    	I am you!
    	""" # special string format
    string = 'xiaoyi' # get value by index
    copy = string[0] + string[1] + string[2:6] # note: [2:6] means [2 5] or[2 6)
    copy = string[:4] # start from 1
    copy = string[2:] # to end
    copy = string[::1] # step is 1, from start to end
    copy = string[::2] # step is 2
    copy = string[-1] # means 'i', the last one
    copy = string[-4:-2:-1] # means 'yoa', -1 step controls direction
    memAddr = id(num) # id(num) get the memory address of num
    type(num) # get the type of num
    

    3、元组

             元组tuple用()来定义。相当于一个可以存储不同类型数据的一个数组。可以用索引来访问,但需要注意的一点是,里面的元素不能被修改。

    ###################################
    ### sequence type #######
    ## can access the elements by index or slice
    ## include: string, tuple(or array? structure? cell?), list
    # basis operation of sequence type
    firstName = 'Zou'
    lastName = 'Xiaoyi'
    len(string) # the length
    name = firstName + lastName # concatenate 2 string
    firstName * 3 # repeat firstName 3 times
    'Z' in firstName # check contain or not, return true
    string = '123'
    max(string)
    min(string)
    cmp(firstName, lastName) # return 1, -1 or 0
    
    ## tuple(or array? structure? cell?)
    ## define this type using ()
    user = ("xiaoyi", 25, "male")
    name = user[0]
    age = user[1]
    gender = user[2]
    t1 = () # empty tuple
    t2 = (2, ) # when tuple has only one element, we should add a extra comma
    user[1] = 26 # error!! the elements can not be changed
    name, age, gender = user # can get three element respectively
    a, b, c = (1, 2, 3)
    

    4、列表

             列表list用[]来定义。它和元组的功能一样,不同的一点是,里面的元素可以修改。List是一个类,支持很多该类定义的方法,这些方法可以用来对list进行操作。

    ## list type (the elements can be modified)
    ## define this type using []
    userList = ["xiaoyi", 25, "male"]
    name = userList[0]
    age = userList[1]
    gender = userList[2]
    userList[3] = 88888 # error! access out of range, this is different with Matlab
    userList.append(8888) # add new elements
    "male" in userList # search
    userList[2] = 'female' # can modify the element (the memory address not change)
    userList.remove(8888) # remove element
    userList.remove(userList[2]) # remove element
    del(userList[1]) # use system operation api
    ## help(list.append)
    
    ################################
    ######## object and class ######
    ## object = property + method
    ## python treats anything as class, here the list type is a class,
    ## when we define a list "userList", so we got a object, and we use
    ## its method to operate the elements
    

    5、字典

             字典dictionary用{}来定义。它的优点是定义像key-value这种键值对的结构,就像struct结构体的功能一样。它也支持字典类支持的方法进行创建和操作。

    ################################
    ######## dictionary type ######
    ## define this type using {}
    item = ['name', 'age', 'gender']
    value = ['xiaoyi', '25', 'male']
    zip(item, value) # zip() will produce a new list: 
    # [('name', 'xiaoyi'), ('age', '25'), ('gender', 'male')]
    # but we can not define their corresponding relationship
    # and we can define this relationship use dictionary type
    # This can be defined as a key-value manner
    # dic = {key1: value1, key2: value2, ...}, key and value can be any type
    dic = {'name': 'xiaoyi', 'age': 25, 'gender': 'male'}
    dic = {1: 'zou', 'age':25, 'gender': 'male'}
    # and we access it like this: dic[key1], the key as a index
    print dic['name']
    print dic[1]
    # another methods create dictionary
    fdict = dict(['x', 1], ['y', 2]) # factory mode
    ddict = {}.fromkeys(('x', 'y'), -1) # built-in mode, default value is the same which is none
    # access by for circle
    for key in dic
    	print key
    	print dic[key]
    
    # add key or elements to dictionary, because dictionary is out of sequence,
    # so we can directly and a key-value pair like this:
    dic['tel'] = 88888 	
    # update or delete the elements
    del dic[1] # delete this key
    dic.pop('tel') # show and delete this key
    dic.clear() # clear the dictionary
    del dic # delete the dictionary
    dic.get(1) # get the value of key
    dic.get(1, 'error') # return a user-define message if the dictionary do not contain the key
    dic.keys()
    dic.values()
    dic.has_key(key)
    # dictionary has many operations, please use help to check out
    

    四、流程控制

             在这块,Python与其它大多数语言有个非常不同的地方,Python语言使用缩进块来表示程序逻辑(其它大多数语言使用大括号等)。例如:

    if age < 21:

        print("你不能买酒。")

        print("不过你能买口香糖。")

    print("这句话处于if语句块的外面。")

             这个代码相当于c语言的:

    if (age < 21)

    {

        print("你不能买酒。")

        print("不过你能买口香糖。")

    }

    print("这句话处于if语句块的外面。")

           可以看到,Python语言利用缩进表示语句块的开始和退出(Off-side规则),而非使用花括号或者某种关键字。增加缩进表示语句块的开始(注意前面有个:号),而减少缩进则表示语句块的退出。根据PEP的规定,必须使用4个空格来表示每级缩进(不清楚4个空格的规定如何,在实际编写中可以自定义空格数,但是要满足每级缩进间空格数相等)。使用Tab字符和其它数目的空格虽然都可以编译通过,但不符合编码规范。

           为了使我们自己编写的程序能很好的兼容别人的程序,我们最好还是按规范来,用四个空格来缩减(注意,要么都是空格,要是么都制表符,千万别混用)。

    1、if-else

             If-else用来判断一些条件,以执行满足某种条件的代码。

    ################################
    ######## procedure control #####
    ## if else
    if expression: # bool type and do not forget the colon
    	statement(s) # use four space key 
    
    if expression: 
    statement(s) # error!!!! should use four space key 
    	
    if 1<2:
    	print 'ok, ' # use four space key
    	print 'yeah' # use the same number of space key
    	
    if True: # true should be big letter True
    	print 'true'
    
    def fun():
    	return 1
    
    if fun():
    	print 'ok'
    else:
    	print 'no'
    	
    con = int(raw_input('please input a number:'))
    if con < 2:
    	print 'small'
    elif con > 3:
    	print 'big'
    else:
    	print 'middle'
    	
    if 1 < 2:
    	if 2 < 3:
    		print 'yeah'
    	else:
    		print 'no'	
    	print 'out'
    else:
    	print 'bad'
    
    if 1<2 and 2<3 or 2 < 4 not 0: # and, or, not
    	print 'yeah'
    

    2、for

             for的作用是循环执行某段代码。还可以用来遍历我们上面所提到的序列类型的变量。

    ################################
    ######## procedure control #####
    ## for
    for iterating_val in sequence:
    	statements(s)
    # sequence type can be string, tuple or list
    
    for i in "abcd":
    	print i
    
    for i in [1, 2, 3, 4]:
    	print i
    
    # range(start, end, step), if not set step, default is 1, 
    # if not set start, default is 0, should be noted that it is [start, end), not [start, end]
    range(5) # [0, 1, 2, 3, 4]
    range(1, 5) # [1, 2, 3, 4]
    range(1, 10, 2) # [1, 3, 5, 7, 9]
    for i in range(1, 100, 1): 
    	print i
    
    # ergodic for basis sequence
    fruits = ['apple', 'banana', 'mango']
    for fruit in range(len(fruits)): 
    	print 'current fruit: ', fruits[fruit]
    
    # ergodic for dictionary
    dic = {1: 111, 2: 222, 5: 555}
    for x in dic:
    	print x, ': ', dic[x]
    	
    dic.items() # return [(1, 111), (2, 222), (5, 555)]
    for key,value in dic.items(): # because we can: a,b=[1,2]
    	print key, ': ', value
    else:
    	print 'ending'
    
    ################################
    import time
    # we also can use: break, continue to control process
    for x in range(1, 11):
    	print x
    	time.sleep(1) # sleep 1s
    	if x == 3:
    		pass # do nothing
    	if x == 2:
    		continue
    	if x == 6:
    		break
    	if x == 7:	
    		exit() # exit the whole program
    	print '#'*50
    

    3、while

             while的用途也是循环。它首先检查在它后边的循环条件,若条件表达式为真,它就执行冒号后面的语句块,然后再次测试循环条件,直至为假。冒号后面的缩近语句块为循环体。

    ################################
    ######## procedure control #####
    ## while
    while expression:
    	statement(s)
    
    while True:
    	print 'hello'
    	x = raw_input('please input something, q for quit:')
    	if x == 'q':
    		break
    else:
    	print 'ending'
    

    4、switch

             其实Python并没有提供switch结构,但我们可以通过字典和函数轻松的进行构造。例如:

    #############################
    ## switch ####
    ## this structure do not support by python
    ## but we can implement it by using dictionary and function
    ## cal.py ##
    #!/usr/local/python
    
    from __future__ import division
    # if used this, 5/2=2.5, 6/2=3.0
    
    def add(x, y):
    	return x + y
    def sub(x, y):
    	return x - y
    def mul(x, y):
    	return x * y
    def div(x, y):
    	return x / y
    
    operator = {"+": add, "-": sub, "*": mul, "/": div}
    operator["+"](1, 2) # the same as add(1, 2)
    operator["%"](1, 2) # error, not have key "%", but the below will not
    operator.get("+")(1, 2) # the same as add(1, 2)
    
    def cal(x, o, y):
    	print operator.get(o)(x, y)
    cal(2, "+", 3)
    # this method will effect than if-else
    


    五、函数

    1、自定义函数

             在Python中,使用def语句来创建函数:

    ################################
    ######## function #####	
    def functionName(parameters): # no parameters is ok
    	bodyOfFunction
    
    def add(a, b):
    	return a+b # if we do not use a return, any defined function will return default None 
    	
    a = 100
    b = 200
    sum = add(a, b)
    
    ##### function.py #####
    #!/usr/bin/python
    #coding:utf8  # support chinese
    def add(a = 1, b = 2): # default parameters
    	return a+b	# can return any type of data
    # the followings are all ok
    add()
    add(2)
    add(y = 1)
    add(3, 4)
    
    ###### the global and local value #####
    ## global value: defined outside any function, and can be used
    ##				in anywhere, even in functions, this should be noted
    ## local value: defined inside a function, and can only be used
    ##				in its own function
    ## the local value will cover the global if they have the same name
    val = 100 # global value
    def fun():
    	print val # here will access the val = 100
    print val # here will access the val = 100, too
    
    def fun():
    	a = 100 # local value
    	print a
    print a # here can not access the a = 100
    
    def fun():
    	global a = 100 # declare as a global value
    	print a
    
    print a # here can not access the a = 100, because fun() not be called yet
    fun()
    print a # here can access the a = 100
    
    ############################
    ## other types of parameters
    def fun(x):
    	print x
    # the follows are all ok
    fun(10)	# int
    fun('hello') # string
    fun(('x', 2, 3))  # tuple
    fun([1, 2, 3])	  # list
    fun({1: 1, 2: 2}) # dictionary
    
    ## tuple
    def fun(x, y):
    	print "%s : %s" % (x,y) # %s stands for string
    fun('Zou', 'xiaoyi')
    tu = ('Zou', 'xiaoyi')
    fun(*tu)	# can transfer tuple parameter like this
    
    ## dictionary
    def fun(name = "name", age = 0):
    	print "name: %s" % name
    	print "age: " % age
    dic = {name: "xiaoyi", age: 25} # the keys of dictionary should be same as fun()
    fun(**dic) # can transfer dictionary parameter like this
    fun(age = 25, name = 'xiaoyi') # the result is the same
    ## the advantage of dictionary is can specify value name
    
    #############################
    ## redundancy parameters ####
    ## the tuple
    def fun(x, *args): # the extra parameters will stored in args as tuple type 
    	print x
    	print args
    # the follows are ok
    fun(10)
    fun(10, 12, 24) # x = 10, args = (12, 24)
    
    ## the dictionary
    def fun(x, **args): # the extra parameters will stored in args as dictionary type 
    	print x
    	print args
    # the follows are ok
    fun(10)
    fun(x = 10, y = 12, z = 15) # x = 10, args = {'y': 12, 'z': 15}
    
    # mix of tuple and dictionary
    def fun(x, *args, **kwargs):
    	print x
    	print args
    	print kwargs
    fun(1, 2, 3, 4, y = 10, z = 12) # x = 1, args = (2, 3, 4), kwargs = {'y': 10, 'z': 12}
    

    2、Lambda函数

             Lambda函数用来定义一个单行的函数,其便利在于:

    #############################
    ## lambda function ####
    ## define a fast single line function
    fun = lambda x,y : x*y # fun is a object of function class
    fun(2, 3)
    # like
    def fun(x, y):
    	return x*y
    
    ## recursion
    # 5=5*4*3*2*1, n!
    def recursion(n):
    	if n > 0:
    		return n * recursion(n-1) ## wrong
    
    def mul(x, y):
    	return x * y
    numList = range(1, 5)
    reduce(mul, numList) # 5! = 120
    reduce(lambda x,y : x*y, numList) # 5! = 120, the advantage of lambda function avoid defining a function
    
    ### list expression
    numList = [1, 2, 6, 7]
    filter(lambda x : x % 2 == 0, numList)
    print [x for x in numList if x % 2 == 0] # the same as above
    map(lambda x : x * 2 + 10, numList)
    print [x * 2 + 10 for x in numList] # the same as above
    

    3、Python内置函数

           Python内置了很多函数,他们都是一个个的.py文件,在python的安装目录可以找到。弄清它有那些函数,对我们的高效编程非常有用。这样就可以避免重复的劳动了。下面也只是列出一些常用的:

    ###################################
    ## built-in function of python ####
    ## if do not how to use, please use help()
    abs, max, min, len, divmod, pow, round, callable,
    isinstance, cmp, range, xrange, type, id, int()
    list(), tuple(), hex(), oct(), chr(), ord(), long()
    
    callable # test a function whether can be called or not, if can, return true
    # or test a function is exit or not
    
    isinstance # test type
    numList = [1, 2]
    if type(numList) == type([]):
    	print "It is a list"
    if isinstance(numList, list): # the same as above, return true
    	print "It is a list"
    	
    for i in range(1, 10001) # will create a 10000 list, and cost memory
    for i in xrange(1, 10001)# do not create such a list, no memory is cost
    
    ## some basic functions about string
    str = 'hello world'
    str.capitalize() # 'Hello World', first letter transfer to big
    str.replace("hello", "good") # 'good world'
    ip = "192.168.1.123"
    ip.split('.') # return ['192', '168', '1', '123']
    help(str.split)
    
    import string
    str = 'hello world'
    string.replace(str, "hello", "good") # 'good world'
    
    ## some basic functions about sequence
    len, max, min
    # filter(function or none, sequence)
    def fun(x):
    	if x > 5:
    		return True
    numList = [1, 2, 6, 7]
    filter(fun, numList) # get [6, 7], if fun return True, retain the element, otherwise delete it
    filter(lambda x : x % 2 == 0, numList)
    # zip()
    name = ["me", "you"]
    age = [25, 26]
    tel = ["123", "234"]
    zip(name, age, tel) # return a list: [('me', 25, '123'), ('you', 26, '234')]
    # map()
    map(None, name, age, tel) # also return a list: [('me', 25, '123'), ('you', 26, '234')]
    test = ["hello1", "hello2", "hello3"]
    zip(name, age, tel, test) # return [('me', 25, '123', 'hello1'), ('you', 26, '234', 'hello2')]
    map(None, name, age, tel, test) # return [('me', 25, '123', 'hello1'), ('you', 26, '234', 'hello2'), (None, None, None, 'hello3')]
    a = [1, 3, 5]
    b = [2, 4, 6]
    def mul(x, y):
    	return x*y
    map(mul, a, b) # return [2, 12, 30]
    # reduce()
    reduce(lambda x, y: x+y, [1, 2, 3, 4, 5]) # return ((((1+2)+3)+4)+5)
    


    展开全文
  • Python学习笔记一(Python基础语法)

    千次阅读 多人点赞 2017-09-20 10:56:23
    目录一、python程序执行(变成方式) 二、Python标识符 四、python多行语句 五、python缩进 六、python的引号,单引号、双引号、三引号 八、python空行、缩进 十、python等待用户输入 十二、python命令行...

    目录

    一、python程序执行(编程方式)
    二、Python标识符 
    四、python多行语句 
    五、python缩进 
    六、python的引号,单引号、双引号、三引号 
    八、python空行、缩进 
    十、python等待用户输入 
    十一、python多个语句组成代码组
    十二、python命令行参数

    一、Python程序执行(编程方式)

    交互式编程

    1. 不需要创建脚本文件,通过 Python 解释器的交互模式执行;
    2. linux、mac,命令行中输入python,进入交互式编程模式
    3. windows下:
      安装python的时候安装了默认的python交互式客户端IDLE(PythonGUI);或者设置python环境变量,windows自带的cmd控制台窗口输入python命令,进入交互式编程模式(command line)

    脚本式编程

    1. 通过脚本参数调用python解释器执行,脚本执行完成,解释器不在有效
    2. 新建一个test.py脚本文件,文件内容如下:
      print “Hello,World!”
      设置python解释器的环境变量,执行命令 :python test.py
    3. 在test.py脚本中指定python解释器,代码如下:
      #!/usr/bin/python
      #设置pyhton解释器的路径,这里是/usr/bin/python,根据实际情况设置
      print “Hello World!”
      给test.py文件赋予可执行权限,并执行
      chmod +x test.py
      ./test.py

    二、Python标识符

    1. 标识符组成:字母、数字、下划线
    2. 标识符规则:区分大小写,不能数字开头
    3. python标识符特殊的规则:
      • 单下划线开头,_foo: 代表不能直接访问的类属性,需通过类提 供的接口进行访问,不能用 from xxx import * 而导入;
      • 双下划线开头,__foo: 代表类的私有成员;
      • 双下划线开头和结尾foo: 代表Python 里特殊方法专用的标识,如 init() 代表类的构造函数

    三、Python保留字符(字段)

    1. 保留字段不能被用于常量、变量、任何其他标识符名称(函数名、类名等)
    2. python保留字段,只包含小写字母
    3. 保留字段如下:
      这里写图片描述

    四、行和缩进

    1. python和其他语言最大的区别,不使用{}来控制类、函数、逻辑判断,使用缩进来写模块
    2. 规则:
      所有的代码块必须包含相同的缩进空白数
      error:IndentationError: unexpected indent
      建议使用tab键、2个/4个空格键来缩进,两者不能混用
      error:IndentationError: unindent does not match any outer indentation level

    五、多行语句

    1. 一行中写多条语句,方法是用;分开

      print 'hello';print 'python';
    2. 多行写一条语句:

      • 斜杠( \)将一行的语句分为多行显示
      • 语句中使用[], {} 或 () 括号直接换行,不需要使用多行连接符
    item1 = 1; item2 = 2; item3 = 3
    total = item1 + \
            item2 + \
            item3;
    print total
    
    days = ['Monday', 'Tuesday', 'Wednesday',
            'Thursday', 'Friday']
    print days[0]

    六、Python的引号,用来表示字符串、注释(多行)

    1. 单引号(’)
    2. 双引号(“)
    3. 三引号(”’或者”“”);
      单引号和双引号用法一样,python支持两种写法,好处如下:
      • 表示字符串 Let’s go
      • 单引号写法,需要转义字符: ‘Let\’ go’
      • 双引号写法,不需要转义字符: “Let’s go”
    4. 字符串需要多行的时候,三种的区别:
      • 单引号、双引号表示多行,需要换行连接符 /
      • 三引号直接换行

    七、python注释

    1. 单行注释,使用#表示
    2. 多行注释,使用三引号(3个单引号、3个双引号)表示
    3. Python的空行、代码缩进
      • 函数、或者类的方法之间,用空行分割;
      • 类和函数入口之间,用一行空行分隔,以突出函数入口的开 始;
      • 空行不是python语法的一部分,即使不用空行隔开,Python解 释器运行也不会报错,空行隔开,是为了更好的代码结构,更好维护代码
      • 缩进是python语法的一部分
      • 记住:空行也是python程序的一部分

    九、print输出

    1. print默认输出是换行的
    2. 实现不换行,在变量后面加上逗号,
    x="Hello"
    y="World!"
    #默认换行
    print x
    print y
    #不换行
    print x,
    print y

    十、Python等待用户输入

    1. 获取用户输入字符串
    2. \n\n”在结果输出前会输出两个新的空行;
    3. 一旦用户按下 enter(回车) 键退出
    enter_string = raw_input("\n\nPress the enter key to exit.")
    print  enter_string

    十一、Python多个语句组成代码组

    1. 代码组:缩进相同的一组语句构成的一个代码块;
    2. 像if、while、def和class这样的复合语句,首行以关键字开始,以冒号( : )结束,该行之后的一行或多行代码构成代码组;
    3. 将首行及后面的代码组称为一个子句(clause),例如:
     if expression :
       suite
     elif expression :
       suite
     else :
       suite
    myAge = 25
    if myAge < 25:
        print("我的年龄小于25")
    elif myAge > 25:
        print("我的年龄大于25")
    elif myAge == 25:
        print("我今年25岁")
    else:
        print "我也不知道你多少岁了……"

    十二、Python命令行参数

    1. 使用脚本形式执行 Python 时,可以接收命令行输入的参数
    2. 查看可传入的参数:python -h
    3. 使用sys模块,获取传入的参数,如下:
        import sys
         print sys.argv
        #sys.argv[0] 代表文件本身路径,所带参数从 sys.argv[1] 开始
    展开全文
  • Python学习笔记

    千次阅读 多人点赞 2019-10-19 07:57:29
    Python 学习笔记(基础) 文章目录Python 学习笔记(基础)0. 简介Python 编程第一步模块与包错误和异常注释1. 数据类型与运算符数据类型操作符2. 控制流分支语句循环语句3. 函数函数声名函数调用变量作用域调用预设...

    Python 学习笔记(基础)

    0. 简介

    Python 编程第一步

    以下所有 Python 程序的运行环境都为Anaconda 3.7

    定义


    • python的源码以.py为拓展名保存,如helloworld.py

    第一个程序:monPremierProg.py


    print( "hello world!" )
    

    在命令行中输出


    在python中用如下语句来做命令行输出:

    • print( message, end = "" ) # 输出message,不换行
      
    • print( message ) # 输出message + 换行
      

    注意如果这个message是混合了字符与数字,则我们要用逗号,将字符与数字分开。Python将会自动在两个值之间加入空格。

    示例


    print( "Vive les loutres", end = "" ) # 打出字符串后不会换行
    print( " et Charlie!" ) # 输出后换行
    i = 1337
    print( "Du texte, 1 variable:", i, " et 1 valeur:", 42 )
    

    以上代码在命令行的输出为:

    Vive les loutres et Charlie!

    Du texte, 1 variable: 1337 et 1 valeur: 42

    在命令行输入


    在python中用如下语句来做命令行输入:

    • input( message ) # 输出 message(可缺省)后等待用户输入
      

    注意input( ) 函数的返回值为字符串,所以我们要将其返回值转换(指派 cast)为我们需要的数据类型(int, float…)。

    示例


    i = int( input( "Entrer un entier: " ) ) # i即为一整型数
    f = float( input( "Entrer un reel: " ) ) # f为一浮点型数
    phrase = input( )                        # 字符串
    

    模块与包


    定义


    • 模块:

      • 包含定义的变量,函数,方法或类等的文件
      • 模块的设计通常遵循对于不同的问题域,有清晰的逻辑边界的原则
    • 包:

      • 将重组后的多个模块包含在同一个目录中
      • 一般在同一个包中的模块都有一个共同点(如汽车的管理,小轿车,卡车等)
      • 文件的名字即为包的名字

    用处


    • 提高代码的复用性,模块化编程
      • 节省时间,避免重复造轮子
      • 提高代码的可读性和可维护性

    语法


    导入包或模块:

    • import random # 导入 random 模块
      
    • from math import acos # 从 math 模块中导入 acos 函数
      
    • from math import * # 导入 math 模块中的所有函数
      

    注意使用 from...import... 这种形式的语句,调用 math 模块中的函数时不需要 math. 前缀。但是使用完整的名称会让代码更可读,所以最好是使用普通形式的 import 语句。

    示例


    from random import random  # random 函数来生成随机数
    import math                # 使用 math 模块中的函数
    
    nAlea = random( )          # 0到1范围内的随机数
    angle = math.acos( nAlea ) # 相应的角度
    print( "acos(", nAlea, ") =", angle, "raid" )
    

    命令行输出为:

    acos( 0.3016517887149436 ) = 1.264371655140188 raid

    错误和异常

    定义


    编程中存在两种错误:

    • 语法错误:程序无法编译
    • 运行时出错(异常):程序无法被正确运行

    语法错误


    • 在编译过程中弹出的错误
    • 没有遵守基本的语法规则(如错误的缩进,变量没有声名…)
    • 易于纠正:可以被解释器检测到并发出信号

    示例


     x = 1
    z = x + a
    print( "z = ", z )
    

    命令行输出为:

    File “main.py”, line 2, in
    z = x + a

    NameError: name ‘a’ is not defined

    File “main.py”, line 1
    x = 1
    ^
    IndentationError: expected an indented block

    异常


    • 程序运行时跳出的错误

      • 程序挂起并出现错误信息
      • 程序产生了错误的运行结果
    • 不易纠正:编译器无法检测到该种错误,必须要一步一步debug程序以检查出哪里出现了异常

    典型异常


    • 出现异常信息

      • 变量没有被创建(AttributeError
      • 访问位置超出数组索引(IndexError
    • 产生错误结果

      • 变量初始化错误
      • 缩进错误
      • 条件总为真/假 \Rightarrow 无法进入循环

    注释


    好处


    • 用来解释代码:

      • 变量的作用
      • 方法的功能
      • 语句的目的
    • 不会被编译 \Rightarrow 不会增加程序运行的负担(所以要多加注释!)

    • 注意在Python中我们经常用 """ 这是注释 """ 的形式来写较长的注释(或多句话)。

    两种注释方法的示例


    # 以下定义函数maMethode( )
    
    def maMethode( param1 ) :
        """ 这是注释一个函数的示例
        	@param param1 定义的函数的第一个参数
        	@return 运行成功返回True,失败则返回False
        	@author YYZ
        	@Version 1.0
        """
    

    1. 数据类型与运算符

    数据类型


    定义


    • Python 有4种默认数据类型
      • 布尔型 boolTrueFalse
      • 整型 int
      • 浮点型 float
      • 字符及字符串 str

    注意


    • Python是一种弱类型语言,变量的类型可在程序运行时被自动的选择或改变
    • 我们可以用函数 type( maVariable ) 来获取变量的数据类型

    类型转换(指派cast)


    • 可在实数与整数之间转换类型
    • 两种转换方式:
      • 扩展:将一个类型转换为较大的类型(隐式的)
      • 缩小:将一个类型转换为较小的类型(必须显式的表示)

    扩展的示例


    i = 42      # i是一个整型数
    f = i + 0.1 # i的值在加上0.1之后被自动转换为浮点型
    

    缩小的示例


    f = 13.37
    # 转换后会缺失精度
    i = int( f ) # i = 13(其值被截断)
    

    错误示例


    f = 0.1  # 没有将所有二进制位全表示出
             # => f的值是被截断的
        	# 所以3*f与0.3所表示的并不一样
    print( 3*f == 0.3 ) # => 输出False
    

    操作符


    操作符 连接性
    () [] . 从左向右
    not 从右向左
    ** 从左向右
    * / // % 从左向右
    + - 从左向右
    < <= > >= isinstance 从左向右
    == != 从左向右
    and 从左向右
    or 从左向右
    = += -= *= /= //= %= 从右向左

    赋值与运算符


    一般赋值符


    s = 0 # 一般赋值
    

    运算符


    a + b
    a - b
    a * b
    a / b
    求商 a // b
    取余 a % b
    a ** b

    示例


    unEntier = 8 + 3           # unEntier = 11
    unEntier = unEntier % 7    # unEntier = 4
    
    unReel = 3.                # unReel = 3.0
    unReel = unReel * unEntier # unReel = 12.0
    unReel = unReel / 5        # unReel = 2.4
    

    赋值运算符


    a += b \Rightarrow a = a + b
    a -= b \Rightarrow a = a - b
    a *= b \Rightarrow a = a * b
    a /= b \Rightarrow a = a / b
    求商 a //= b \Rightarrow a = a // b
    取余 a %= b \Rightarrow a = a % b
    a **= b \Rightarrow a = a ** b
    • 使用这种赋值运算符可以精简代码

    示例


    unEntier = 8 + 3   # unEntier = 11
    unEntier %= 7      # unEntier = 4
    
    unReel = 3.        # unReel = 3.0
    unReel *= unEntier # unReel = 12.0
    unReel /= 5        # unReel = 2.4
    

    关系运算符


    小于 a < b a <= b
    大于 a > b a >= b
    等于 a == b
    不等于 a != b

    逻辑运算符


    非逻辑 not a(a 必须是布尔型)
    与逻辑 a and b
    或逻辑 a or b

    示例


    val1, val2 = 1, 2
    b = (val1 == 1) and (val2 > 2)
    print( "(val1 = 1 ET val2 > 2) est ", b )
    b = not (val1 == 1) or (val2 > 2)
    print( "(val1 != 1 OU val2 > 2) est ", b )
    

    运行结果为:

    (val1 = 1 ET val2 > 2) est False

    (val1 != 1 OU val2 > 2) est False

    2. 控制流

    分支语句


    if 语句


    当判断条件为真时则执行语句或代码块:

    if condition :
        # 当 condition 为真(True)时语句或代码块会被执行
        # 代码块中所有相同缩进的语句
        # 将会被执行
    

    注意

    • 判定条件为假时代码不会被执行
    • 在Pyhton中,代码块完全是靠各语句之间的缩进关系定义的

    else 子句


    定义了当判定条件不满足时程序将执行的语句:

    if condition :
        # 当 condition 为 True 时执行此处代码块
    else :
        # 当 condition 为 False 时则执行此处代码块
    

    if … else 语句串联


    可以将多个 if … else 语句相连:

    if condition1 :
        # 如果 condition1 为真执行此处语句
    elif condition2 :
        # 当 condition1 为假但 condition2 为真时
        # 执行此处语句
    else :
        # 当 condition1 和 condition2 都为假时
        # 执行此处语句
    

    示例


    if unEntier % 2 == 0 :
        print( unEntier, " est pair." )
    else :
        print( unEntier, " est impair." )
        
    if unReel > 0 :
        print( unReel, " est positif." )
    elif unReel < 0 :
        print( unReel, " est negatif." )
    else :
        print( unReel, " est nul." )
    

    单行分支语句


    if condition :
        uneVar = valeurVraie
    else :
        uneVar = valeurFausse
    

    我们可以将以上代码改写为一行(类似 C 语言的 ? 运算符):

    uneVar = valeurVrais if condition else valeurFausse
    

    示例


    dX = int( input( "Entrer un deplacement lateral: " ) )
    gaucheOuDroite = "gauche" if dX < 0 else "droite"
    print( "Vous avez entre", dX, end = "" )
    print( " et nous allons donc a", gaucheOuDroite )
    

    循环语句


    定义


    • 使用循环语句可将一段代码块按顺序执行多次

    • 两种循环方法:

      • 代码块要重复执行的次数未知:使用入口条件判定循环语句

        while : 在进入循环前对循环条件进行判断,其中的代码块可能不会被执行

      • 代码块要重复执行的次数已知:带计数的循环

        for

    for 循环


    • 循环的次数已知

    • 带计数的循环:须指定以下参数

      • 计数器初值
      • 计数器终值
      • 计数器在每次执行完代码块后自增的步长
      for uneVar in range( debut, fin, incrementation ) :
          # 要循环的代码块
      
      • 注意

        • uneVar 变量的值从 debut 开始,每次执行完代码块后自增 incrementation ,直到其值为 fin

        • 计数器的初值和步长可以省略

          for uneVar in range( fin ) :
              # 代码块
          

          此时默认初值为0,自增步长为1

        • 注意缩进!

    示例


    """ 一般循环 """
    # 输出0到10之前的所有整数
    for i in range ( 10 ) :
        print( i )
        
    """ 反向循环 """
    # 按顺序输出3之前到1的整数
    for i in range( 3, 0, -1 ) : # i 每次自减1
        print( i )
        
    """ 任意步长循环 """
    # 输出10之前的所有偶数
    for i in range( 0, 10, 2 ) : # i 每次自增2
        print( i )
    

    while 循环


    定义


    • 循环次数未知

    • 是否继续循环的条件在循环的入口处判定

    • 要在循环开始前初始化一些变量(如用作计数的变量)

    • 如果循环的初始条件判定为假,则程序不会执行循环中的任何语句

    • 如果循环是否继续的条件判定一直不为假,则程序将不会跳出该循环(我们称之为无限循环)

      \Rightarrow 在循环中一个或多个语句会处理与循环继续条件有关的变量来递进该变量使循环走向结束

    语法


    while condition :
        # 代码块
    

    示例


    计算两个整数 a 除 b 的商及余数,不使用运算符 //% :

    • 已知商和余数的初值(q = 0,r = a)
    • 循环次数未知
    • 当 b > a 时不能进入循环(循环继续条件)

    \Rightarrow 可以使用 while 循环

    # 让用户输入 a 和 b
    a = int( input( ) )
    b = int( input( ) )
    q, r = 0, a
    while r >= b :
        q += 1 # 每次使商自增1
        r -= b # 每次使余数自减 b => 修改停止循环条件的变量的值
    print( a, " = ", b, " * ", q, " + ", r )
    

    for 循环转换为 while 循环


    #         初始化,检测,自增
    for i in rang( 0, 4, 1 ) :
        print( i )
    
    i = 0         # 初始化
    while i < 4 : # 检测
        print( i )
        i += 1    # 自增
    

    3. 函数

    函数声名


    函数声名语法


    关键字:def

    def nomMethode( parametres ) :
        # 函数的代码块
        # 注意缩进!
    
    • parametres :函数的形参列表,多个参数时每个参数之间用逗号 , 隔开
    • 注意当函数没有形参时 \Rightarrow 空括号

    示例


    # 无参数的函数
    def afficheLoutre( ) :
        print( "Vive les loutres!" )
    
    # 单个参数的函数
    def afficheSigne( n ) :
        if n >= 0 :
            print( "n est positif" )
        else :
            print( "n est negatif" )
            
    # 多个参数的函数   
    def afficheSigne( n, nom ) :
        print( nom, "est", "positif" if n >= 0 else "negatif" )
    

    函数的返回值语法


    def nomMethode( parametres ) :
        """ 代码块
            ...
        """ 
        return uneValeur # 函数运行的结果
    
    • 返回值 = 函数的运行结果

    • 关键字 return

      • 函数运行至该语句时结束
      • 向后面的语句传递运行结果
    • 没有返回值 \Rightarrow

      • 函数在代码块结尾处结束运行
      • 不用写 return

    示例


    def somme( a, b ) :
        res = a + b
        return res
    
    def max( a, b ) :
        if a >= b :
            return a
        else :
            return b
        
    def affiche( x ) :
        print( "x =", x )
    

    函数调用


    • 当一个函数被定义之后并不会被执行,只有当其被主程序或其他函数调用后才会被运行
    • 形参与实参:
      • 函数的形参的作用域仅存在于该函数的局部作用域内
      • 一个函数被调用后,需要将其所需数据作为参数传递给函数 \rightarrow 实参
      • 一个实参可以是一个变量,可以是一个表达式,也可以是另一个函数的返回值

    语法


    • 无返回值的函数:

      nomMethode( parametres_effectifs )
      
    • 有返回值的函数:

      variable = nomMethode( parametres_effectifs )
      

    注意

    • 函数或方法必须在其被调用前声名
    • 函数实参的数量和顺序必须和其形参一样

    示例


    def somme( a, b ) :                 # 此处 a, b 为函数的形参
        return a + b
    
    def afficheSomme( a, b ) :
        s = somme( b, a )               # 此处 b, a 为被调用函数的实参
        print( "La somme est", s )
        
    x = 4
    res = somme( x, 38 )                # x, 38为函数的实参
    print( "res =", res )
    afficherSomme( 13, somme( x, 38 ) ) # 13, somme( x, 38 ) 为函数的实参
    

    变量作用域


    局部和全局变量变量


    • 在一个函数中被声名的变量,处于该函数的局部作用域中。处于局部作用域的变量即为局部变量
    • 在所有函数外声名的变量,属于全局作用域。处于全局作用域的变量即为全局变量

    变量作用域


    • 一个变量的作用域定义了该变量在程序中能被使用的区域
    • 全局作用域中的代码不能使用任何局部变量
    • 一个函数的形参即为该函数被调用时初始化的局部变量

    示例


    def somme( a, b ) :     # a, b 为函数的形参
        res = a + b
        return res          # res 为作用域在该函数中的局部变量
    
    a = 4                   # 此处 a 为全局变量
    print( somme( 38, a ) ) 
    

    注意如果在不同的作用域中,你可以用相同的名字命名不同的变量(如以上代码中的全局变量 asomme 函数中的形参 a

    调用预设函数


    • round( x ) :返回浮点数 x 的四舍五入值
    • abs( x ) :返回 x|x|

    模块 math 中的常用函数:


    • sqrt( x )x\sqrt{x}
    • cos( x )sin( x )tan( x )cos\cossin\sintan\tan ( x 的单位为弧度)
    • exp( x )log( x )exe^xln(x)\ln(x)
    • math.piπ\pi

    模块 random 中的常用函数:


    • random( ) :生成0到1(不包括1)之间的随机实数
    • randint( a, b ) :生成 a 到 b 之间(包括两端)的随机整数

    示例


    # 导入模块
    import math
    import random
    
    x = abs( round( 13.75 ) )                      # 求四舍五入并取绝对值
    cosPi4 = math.cos( math.pi / 4 )               # 计算 cos( pi / 4 )
    cosEgal = ( cosPi4 == ( 1 / math.sqrt( 2 ) ) ) # 比较 cos( pi / 4 ) 与 1 / sqrt( 2 )
    de = random.randint( 1, 6 )                    # 生成1到6之间的随机整数
    

    4. 列表

    声名与使用

    声名列表


    一般我们有:

    • 大小固定
    • 列表的数据项不需要具有相同的类型
    • 用下标来寻址
    • 其存储在内存中的一块连续区域

    语法


    tabEntier = [ ]             # 空列表
    tabEntier1 = [ 0 ] * 4      # 列表中4个元素全为0
    tabEntier2 = [ 1, 3, 3, 7 ] # 含有4个元素的列表
    

    列表的使用


    • 访问列表中的值
      • 我们通过用列表的下标做索引来访问列表中的值:tab[i]
      • 注意:列表的下标是从0到 n - 1 ( n 是列表的大小)
      • 可以使用-1下标来访问列表最后一个元素
    • 向列表尾端添加元素:tab.append( val )
    • 列表的长度:len( tab )

    示例


    tabEntier = [1, 3, 3, 7]
    tabEntier[2] = 42        # 修改列表的第三个元素
    i = tabEntier[0]         # i 的值为列表第一个元素的值
    
    tabEntier.append(142857) # 在列表末尾加入新元素
    print( tabEntier[-1] )   # 输出列表最后一个元素
    
    lTab = len( tab )        # 列表的长度
    tabEntier[lTab] = 2      # 错误!列表的最大下标是 lTab - 1
    
    • 列表的截取有类似 “Matlab” 的语法:sousTab = tab[a : b : c]
      • a :起始下标(默认为0)
      • b :终止下标(默认到最后一个元素)
      • c :步长(默认为1)
    • 注意:我们截取列表的范围为 [a,b[[ a, b [

    示例


    tab = [i for i in range( 20 )] # 列表元素为从0到19的全部整数
    
    sTab = tab[0 : 10 : 1]         # 以1为步长截取下标从0到9的元素
    sTab = tab[0 : 10 : 2]         # 以2为步长截取下标从0到10(不包括)的元素
    
    # 反向截取
    sTab = tab[10 : 0 : -1]        # 截取下标从10到0(不包括)的所有元素
    
    # 可忽略一些参数
    sTab = tab[0 : 10]             # 0到10(不包括)的所有元素
    sTab = tab[: 10 : 2]           # 以2为步长截取下标从0到10(不包括)的元素
    sTab = tab[10 : : 1]           # 截取下标从10之后的所有元素
    sTab = tab[: : 2]              # 截取所有偶数下标的元素
    
    • 遍历整个列表 \Rightarrow 使用 for 循环:

      # 循环访问列表中的所有元素
      for i in range( len( tab ) ) :
          # 代码块
      

    示例


    # 输出列表中的所有元素
    for i in range( len( tab ) ) :
        print( tab[i], " ", end = "" )
    print( "" ) # 回到新的一行
    
    # 寻找列表中最大的元素和它的下标
    maxT = 0
    posT = 0
    for i in range( len( tab ) ) :
        if maxT < tab[i] :
            maxT = tab[i]
            posT = i
    
    • 完全遍历的缩略语法,如果我们需要:

      • 列表中的所有值:for valT in tab

      • 列表中的值和它们的下标:for i, valT in enumerate( tab )

        使用 enumerate 可以返回列表中的元素和它们对应的下标

    示例


    # 输出列表所有的元素
    for valT in tab :                # valT 变量依次遍历列表元素的值
        print( valT, " ", end = "" )
    print( "" )
    
    # 找到列表元素的最大值和其下标
    maxT = 0
    posT = 0
    # 使用 enumerate
    for i, valT in enumerate( tab ) :
        if maxT < valT : 
            maxT = valT
            posT = i
    
    • 部分遍历列表,且不知道循环的次数 \Rightarrow 使用 while 循环:

      i = 0
      while i < len( tab ) and condition :
          # 代码块
          i += 1
      

    示例


    # 寻找列表中第一个5
    i = 0
    while i == len( tab ) and tab[i] != 5 :
        i += 1
    if i == len( tab ) :
        print( "Pas de 5 dans le tableau" )
    else :
        print( "Le 1er 5 est a la position", i )
    

    二维列表(矩阵)

    定义


    • 一个矩阵可视为:一个列表,它其中的所有元素都为一个列表
    • 声名:
      • 空矩阵:mat = [ ]
      • n×mn\times m 阶矩阵,且其元素都相同:mat = [[val] * m] * n
      • 一般的矩阵:mat = [[val11, val12, ...], [val21, val22, ...], ...]
    • 使用:访问第 i 行第 j 列的元素:mat[i][j]

    示例


    from random import randint
    # 初始化一个 n x m 阶的矩阵,其元素为 a 到 b 之间的随机数
    n, m = 13, 37
    a, b = 1, 6
    mat = [[randint( a, b ) for _ in range( m )] for _ in range( n )]
    
    # 截取一整行
    tab = mat[1]
    
    # 输出矩阵中所有的元素
    for i in range( len( mat ) ) :            # 遍历行
        for j in range( len( mat[i] ) ) :     # 遍历列
            print( mat[i][j], " ", end = "" )
        print( "" )
    

    5. 字符串

    定义与语法


    语法


    • 用两个双引号""或单引号' 将构成字符串的值包围

    • + 操作符:

      • 可以将多个字符串串连为一个字符串
      • 如果操作数不是字符串,则要先使用str( val )将其转换为字符串
    • 注意一个字符串即为一个列表,因此我们有:

      • 字符串的长度:len( chaine )

      • 访问字符串中的一个字符 :c = chaine[pos]

        pos是一个在0到 len( chaine ) - 1之间的整数

    示例


    # 声名字符串
    chaine = 'Vive les loutres'
    chaine2 = "Des nombres (42, 142.857) et des symboles (&, _)"
    
    # 串连两个字符串
    chaine += " et Charlie"
    # 此时 chaine 字符串为 "Vive les loutres et Charlie"
    
    # 串连一个字符串和一个数字
    chaine = "La reponse est " + str( 42 )
    # 此时 chaine 值为 "La reponse est 42"
    
    # 串连字符串与变量
    i = 4
    x = 3.
    chaine = str( x ) + "^" + str( i ) + "=" + str( x ** i )
    # 此时 chaine 值为 "3.0^4 = 81.0"
    

    常用函数


    注意 :

    • 字符串方法的调用方式为:nomVaribale.nomMethode( parametres )

    比较两个字符串:

    • 我们可以使用 <>== 运算符来比价两个字符串

    从字符串中检索子字符:

    • idx = chaine.find( car )
    • 从一个位置开始 :idx = chaine.find( car, debut )
    • 在一个区间中检索 :idx = chaine.find( car, debut, fin )

    注意如果包含子字符串则返回开始的索引值,否则返回 -1

    操作字符串:

    • 截取子字符串 :chaine2 = chaine[deb : fin]

      注意:子字符串中不包括fin处的字符

    • 对字符串切片 :tabChaine = chaine.split( c )

    • 替换字符:chaine2 = chaine.replace( oldChar, newChar )

    • 将字符串全转换为小写字母:chaine2 = chaine.lower( )

    • 将字符串全转换为大小字母:chaine2 = chaine.upper( )

    一个列表,因此我们有:*

    • 字符串的长度:len( chaine )

    • 访问字符串中的一个字符 :c = chaine[pos]

      pos是一个在0到 len( chaine ) - 1之间的整数

    示例


    # 声名字符串
    chaine = 'Vive les loutres'
    chaine2 = "Des nombres (42, 142.857) et des symboles (&, _)"
    
    # 串连两个字符串
    chaine += " et Charlie"
    # 此时 chaine 字符串为 "Vive les loutres et Charlie"
    
    # 串连一个字符串和一个数字
    chaine = "La reponse est " + str( 42 )
    # 此时 chaine 值为 "La reponse est 42"
    
    # 串连字符串与变量
    i = 4
    x = 3.
    chaine = str( x ) + "^" + str( i ) + "=" + str( x ** i )
    # 此时 chaine 值为 "3.0^4 = 81.0"
    

    常用函数


    注意 :

    • 字符串方法的调用方式为:nomVaribale.nomMethode( parametres )

    比较两个字符串:

    • 我们可以使用 <>== 运算符来比价两个字符串

    从字符串中检索子字符:

    • idx = chaine.find( car )
    • 从一个位置开始 :idx = chaine.find( car, debut )
    • 在一个区间中检索 :idx = chaine.find( car, debut, fin )

    注意如果包含子字符串则返回开始的索引值,否则返回 -1

    操作字符串:

    • 截取子字符串 :chaine2 = chaine[deb : fin]

      注意:子字符串中不包括fin处的字符

    • 对字符串切片 :tabChaine = chaine.split( c )

    • 替换字符:chaine2 = chaine.replace( oldChar, newChar )

    • 将字符串全转换为小写字母:chaine2 = chaine.lower( )

    • 将字符串全转换为大小字母:chaine2 = chaine.upper( )

    展开全文
  • Python学习笔记(一)

    万次阅读 多人点赞 2018-06-19 09:20:53
    个人学习笔记:# 引入copy模块 import copy # python数据类型:整型、浮点型、字符串、list、tuple、dict、set等 # 转义字符串'I\'m \"OK\"' = I'm "OK" # \n表示换行符,\t表示制表符tab,\ 这...
  • python学习笔记

    2019-09-05 21:13:48
    git操作: 1.git init [project-name] 2.git clone url 克隆文件 3.git status 查看目前状态 4.git add ....5.git commit -m "[descriptive message]" 提交更改 ...6.git push [alias] [branch] 推送文件 ...
  • Python学习笔记No1

    千次阅读 多人点赞 2019-10-24 21:29:49
    一、基础 1、注释 单行注释 - 以#和空格开头的部分 多行注释 - 三个引号开头,三个引号结尾 2、运算符 示例1 a = 5 print("a = ", a) .../usr/bin/python # -*- coding: latin-1 -*- import os, sys f = float...
  • 小甲鱼《零基础入门学习Python学习笔记

    千次阅读 多人点赞 2018-09-06 23:34:31
    根据老师的建议,现在将第二次复习小甲鱼的《零基础入门学习Python》而做的学习笔记,上传到网上,方便今后复习和保存,因为是手写的,所以做了扫描锐化处理,方便阅读。 ...
  • 一般语言都是通过{}来标识代码块的,而在python中,是通过缩进来识别代码块的,这是Python有别于其他编程语言的几个重要特性之一。一般来说,缩进几个空格或者tab都是可以的,只要你保持一致就可以。不过为了别人...
  • Python3.7学习笔记】一、环境搭建

    千次阅读 2019-11-14 11:26:57
    Python3.7学习笔记】一,环境搭建 【Python3.7学习笔记】一,环境搭建 Markdown和扩展Markdown简洁的语法 代码块高亮 图片链接和图片上传 LaTex数学公式 UML序列图和流程图 离线写博客 导入导出Markdown文件 ...
  • 学习Python的做笔记神器——Jupyter Notebook

    万次阅读 多人点赞 2018-03-17 16:41:59
    学习Python的做笔记神器——Jupyter Notebook 给想学好Python的同学们安利一波,Jupyter Notebook是学习Python最好的做笔记环境,没有之一哦。 Jupyter Notebook(又称IPython Notebook)是一个交互式的笔记本,...
  • 【机器学习】实战系列

    千次阅读 多人点赞 2020-01-17 16:57:24
    1、Python3《机器学习实战》学习笔记(一):k-近邻算法(史诗级干货长文) 2、Python3《机器学习实战》学习笔记(二):决策树基础篇之让我们从相亲说起 3、Python3《机器学习实战》学习笔记(三):决策树实战篇之...
  • 学习Python3的精品笔记

    万次阅读 2018-02-07 23:29:42
    石墨文档地址: https://shimo.im/docs/fooucf8wa8EtAB32/ 「Python学习笔记
  • Python3.7学习笔记】二、第一个python程序 目录 目录 编写helloworld.py文件 执行python程序 小结 编写helloworld.py文件 新建helloworld.py文件,输入内容如下: print(“Hello World!”) ...
  • boost_Python 安装和使用

    千次阅读 2017-02-26 22:37:07
    项目中需要将C++的程序暴露给网络使用,我也不想使用C++来用网络编程,就想到可以使用Python来解决Web端,然后将 C++ 的接口暴露给 Python 。于是在寻求解决方案的时候找到了 boost.python 库。 boost 中的 ...
  • Python 入门教程29篇

    千次阅读 多人点赞 2020-04-10 07:57:05
    Python学习笔记(1)-序言 Python学习笔记(2)-开发环境配置 Python学习笔记(3)-第一个程序 Python学习笔记(4)-基本的数据类型 Python学习笔记(5)-集成开发环境IDLE的使用与调试 Python学习笔记(6)-顺序结构与空格、...
  • Python菜鸟教程全目录

    万次阅读 多人点赞 2019-03-06 18:27:14
    但是随着对Python学习的深入,我发现已经逐渐喜欢上了这个简约的语言!但是怎奈我脑子笨、技术功底差、忘性强,急切的需要一个做学习笔记的好地方。由于CSDN人气旺、大牛多,于是就选择在CSDN定居。但是随着笔记越...
  • 【C语言与Python学习笔记目录】

    千次阅读 2019-11-19 22:14:41
    【C语言与Python学习笔记目录】 为了极大程度地方便大家查阅资料,我特地将C语言和Python的学习笔记整理成目录的形式,大家直接就可以链接进去,就不用了找了,只需收藏本页就可以。 小白之路艰辛,希望在帮助到大家...
  • python学习之路 - 从入门到精通到大师

    千次阅读 多人点赞 2020-04-03 21:43:44
    专栏【Python - 100天从新手到大师】 作为目前最火也是最实用的编程语言,Python不仅是新手入门程序界的首选,也逐渐成为了从大厂到小厂,招牌需求list的必要一条。然而你可能也和我一样,已经下了一百次决心,但是...
  • 雨痕 的《Python学习笔记
1 2 3 4 5 ... 20
收藏数 142,061
精华内容 56,824
关键字:

python学习笔记