码迷,mamicode.com
首页 > 编程语言 > 详细

此篇文章献给还处于Python零基础的小白们!保证你能入门不是问题

时间:2018-05-20 21:18:02      阅读:189      评论:0      收藏:0      [点我收藏+]

标签:特征   数据转换   dex   出现   exe   获取   偶数   调用函数   创建   

技术分享图片

更多案例请关注我的博客:home.cnblogs.com/u/Python1234

欢迎大家加入千人交流资源共享群:125240963

技术分享图片

  • 表示什么都没有

  • 如果函数没有返回值,可以返回 None

  • 用来占位

三、内置数据结构

  • list

  • set

  • dict

  • tuple

list(列表)

# 1, 创建空列表 l1 =

[]

# 2. 创建带值的列表 l2 = [ 100

]

# 3. 创建列表,带多个值 l3 = [ 2 , 3 , 1 , 4 , 6 , 4 , 6

]

# 4. 使用list() l4 = list()

技术分享图片

技术分享图片

技术分享图片

技术分享图片

  • # 用list a创建一个list b # 下面代码的含义是,对于所有a中的元素,逐个放入新列表b中 b = [i * 10 for i in

    a]

    # 还可以过滤原来list中的内容病放入新列表 # 比如原有列表a, 需要把所有a中的偶数生成新的列表b a = [x for x in range( 1 , 35 )] # 生成从1到34的一个列表 # 把a中所有偶数生成一个新的列表 b b = [m for m in a if m % 2 ==

    0]

    # 列表生成式可以嵌套 # 由两个列表a,b a = [i for i in range( 1 , 4 )] # 生成list a b = [i for i in range( 100 , 400 ) if i % 100 ==

    0]

    # 列表生成是可以嵌套,此时等于两个for循环嵌套 c = [ m + n for m in a for n in

    b]

    # 上面代码跟下面代码等价 for m in

    a:

    for n in

    b:

    print (m + n, end = " "

    )

    # 嵌套的列表生城市也可以用条件表达式 c = [ m + n for m in a for n in b if m + n < 250 ]

  • 关于列表的常用函数

    • copy: 拷贝,此函数是浅拷贝

      b = a.copy()

    • count:查找列表中指定值或元素的个数

      a_len = a.count( 8 )

    • extend:扩展列表,两个列表,把一个直接拼接到后一个上

      a = [ 1 , 2 , 3 , 4 , 5

      ]

      b

      = [ 6 , 7 , 8 , 9 , 10

      ]

      a.extend(b)

    • remove:在列表中删除指定的值的元素(如果被删除的值没在list中,则报错)

    • clear:清空

    • reverse:翻转列表内容,原地翻转

      a = [ 1 , 2 , 3 , 4 , 5

      ]

      a.reverse()

    • del 删除

    • pop,从对位拿出一个元素,即把最后一个元素取出来

      last_ele = a.pop()

    • insert: 制定位置插入

      # insert(index, data), 插入位置是index前面 a.insert( 3 , 666 )

    • append 插入一个内容, 在末尾追加

      a = [ i for i in range( 1 , 5

      )]

      a.append(

      100 )

    • min

    • list:将其他格式的数据转换成list

      # 把range产生的内容转换成list print (list(range( 12 , 19 )))

    • max:求列表中的最大值

      b = [ ‘ man ‘ , ‘ film ‘ , ‘ python ‘

      ]

      print (max(b))

    • len:求列表长度

      a = [x for x in range( 1 , 100

      )]

      print (len(a))

tuple(元组)

# 创建空元组 t =

()

# 创建一个只有一个值的元组 t = ( 1

,)

t

= 1

,

# 创建多个值的元组 t = ( 1 , 2 , 3 , 4 , 5

)

t

= 1 , 2 , 3 , 4 , 5 # 使用其他结构创建 l = [ 1 , 2 , 3 , 4 , 5

]

t

= tuple(l)

元组的特性

  • 是序列表,有序

  • 元组数据值可以访问,不能修改

  • 元组数据可以是任意类型

  • list所有特性,除了可修改外,元组都具有

元组的函数

  • len: 获取元组的长度

  • max, min:最大最小值

  • count: 计算制定数据出现的次数

  • index:求制定元素在元组中的索引位置

set(集合)

# 集合的定义 s =

set()

# 此时,大括号内一定要有值,否则定义出的是一个dict s = { 1 , 2 , 3 , 4 , 5 , 6 , 7

}

# 如果只是用大括号定义,则定义的是一个dict类型 d = {}

集合的特征

  • 集合内数据无序,即无法使用索引和分片

  • 集合内部数据元素具有唯一性,可以用来排除重复数据

  • 集合内的数据,str, int, float, tuple,冰冻集合等,即内部只能放置可哈希数据

集合序列操作

  • 成员检测(in,not in)

  • 遍历

# for 循环 s = { 4 , 5 , " i "

}

for i in

s:

print (i, end = " "

)

# 带有元组的集合遍历 s = {( 1 , 2 , 3 ), ( " just " , " for " , " fun " ), ( 4 , 5 , 6

)}

for k,m,n in

s:

print (k, " -- " , m, " -- "

, n)

for k in

s:

print (k)

集合的内涵

# 普通集合内涵 # 以下集合在初始化后自动过滤掉重复元素 s = { 23 , 223 , 545 , 3 , 1 ,2 , 3 , 4 , 3 , 2 , 3 , 1 , 2 , 4 , 3

}

# 普通集合内涵 ss = {i for i in

s}

# 带条件的集合内涵 sss = {i for i in s if i % 2 ==

0}

# 多循环的集合内涵 s1 = { 1 , 2 , 3 , 4

}

s2

= { " just " , " for " , " fun "

}

s

= {m * n for m in s2 for n in

s1}

s

= {m * n for m in s2 for n in s1 if n == 2 }

集合函数

  • len, max, min

  • set:生成一个集合

  • add:向集合内添加元素

  • clear

  • copy

  • remove:移除制定的值,直接改变原有值,如果要删除的值不存在,报错

  • discard:移除集合中指定的值,跟 remove 一样,但是入股要删除的话,不报错

  • pop 随机移除一个元素

  • 函数

  • intersection: 交集

  • difference:差集

  • union: 并集

  • issubset: 检查一个集合是否为另一个子集

  • issuperset: 检查一个集合是否为另一个超集

技术分享图片

  • # 创建 s = frozenset()

dict(字典)

  • 没有顺序的组合数据,数据以键值对形式出现

    # 字典的创建 # 创建空字典1 d =

    {}

    # 创建空字典2 d =

    dict()

    # 创建有值的字典, 每一组数据用冒号隔开, 每一对键值对用逗号隔开 d = { " one " : 1 , " two " : 2 , " three " : 3

    }

    # 用dict创建有内容字典1 d = dict({ " one " : 1 , " two " : 2 , " three " : 3

    })

    # 用dict创建有内容字典2 # 利用关键字参数 d = dict(one = 1 , two = 2 , three = 3

    )

    # d = dict( [( " one " , 1 ), ( " two " , 2 ), ( " three " , 3 )])

字典的特征

  • 字典是序列类型,但是是无序序列,所以没有分片和索引

  • 字典中的数据每个都有键值对组成,即kv对

    • key: 必须是可哈希的值,比如int,string,float,tuple, 但是,list,set,dict 不行

    • value: 任何值

字典常见操作

# 访问数据 d = { " one " : 1 , " two " : 2 , " three " : 3

}

# 注意访问格式 # 中括号内是键值 print (d[ " one "

])

d[

" one " ] = " eins " # 删除某个操作 # 使用del操作 del d[ " one "

]

# 成员检测, in, not in # 成员检测检测的是key内容 d = { " one " : 1 , " two " : 2 , " three " : 3

}

if 2 in

d:

print ( " value "

)

if " two " in

d:

print ( " key "

)

if ( " two " , 2 ) in

d:

print ( " kv "

)

# 按key来使用for循环 d = { " one " : 1 , " two " : 2 , " three " : 3

}

# 使用for循环,直接按key值访问 for k in

d:

print

(k, d[k])

# 上述代码可以改写成如下 for k in

d.keys():

print

(k, d[k])

# 只访问字典的值 for v in

d.values():

print

(v)

# 注意以下特殊用法 for k,v in

d.items():

print (k, ‘ -- ‘ ,v)

字典生成式

d = { " one " : 1 , " two " : 2 , " three " : 3

}

# 常规字典生成式 dd = {k:v for k,v in

d.items()}

# 加限制条件的字典生成式 dd = {k:v for k,v in d.items() if v % 2 == 0}

字典相关函数

  • len, max, min, dict

  • str(字典): 返回字典的字符串格式

  • clear: 清空字典

  • items: 返回字典的键值对组成的元组格式

  • keys:返回字典的键组成的一个结构

  • values: 同理,一个可迭代的结构

  • get: 根据制定键返回相应的值

    d = { " one " : 1 , " two " : 2 , " three " : 3

    }

    print (d.get( " on333 "

    ))

    # get默认值是None,可以设置 print (d.get( " one " , 100 ))

  • fromkeys: 使用指定的序列作为键,使用一个值作为字典的所有的键的值

    l = [ " eins " , " zwei " , " drei "

    ]

    # 注意fromkeys两个参数的类型 # 注意fromkeys的调用主体 d = dict.fromkeys(l, " oops " )

四、表达式

运算符

  • 算数运算符

  • 比较或者关系运算符

  • 赋值运算符

  • 逻辑运算符

  • 位运算

  • 成员运算

  • 身份运算符

算数运算符

  • 加 +

  • 减 -

  • 乘 *

  • 除 /

  • 取余 %

  • 取商(地板除) //

  • 幂运算 **

  • :warning:Python 没有自增自减运算符

比较运算符

  • ==

  • !=

  • >=

  • <=

  • 比较的结果是布尔值(True/False)

赋值运算符

  • += (-=, ×=, /=, //=, %=, **=)

逻辑运算符

  • and 逻辑与

  • or 逻辑或

  • not 逻辑非

  • 结果如果是0则为False, 否则为True

  • 短路

  • Python 中没有异或运算

成员运算符号

  • 用来检测某一个变量是否是另一个变量的成员

  • in

  • not in

身份运算

  • is: 用来检测两个变量是否是同一个变量

  • is not: 两个变量不是同一个变量

运算符的优先级

  • 括号具有最高优先级

    ** 指数 (最高优先级)

    ~ + - 按位翻转

    ,

    一元加号和减号 (最后两个的方法名为 +@ 和 -@)

    * / % // 乘,除,取模和取整除

    + - 加法减法

    \>> << 右移,左移运算符

    & 位 ‘AND‘

    ^ | 位运算符

    <

    = < > > =

    比较运算符

    <>

    == ! =

    等于运算符

    = % = / = // = - = + = * = ** =

    赋值运算符

    is is not 身份运算符

    in not in 成员运算符

    not or and 逻辑运算符

五、程序结构

顺序

分支

  • 基本语法

    # 表达式后面的冒号不能少 # 用缩进来表示同一个代码块 if

    条件表达式:

    语句1

    语句2

    语句3

    技术分享图片

    ..

  • 双向分支

    # if 和 else 一个层级,其余语句一个层级 if

    条件表达式:

    语句1

    语句2

    技术分享图片

    else

    :

    语句1

    语句2

    技术分享图片

  • 多路分支

    if

    条件表达式:

    语句1

    技术分享图片

    .

    elif

    条件表达式:

    语句1

    技术分享图片

    elif

    条件表达式:

    语句1

    技术分享图片

    技术分享图片

    ..

    else

    :

    语句1

    技术分享图片

    .

  • Python 没有 switch-case 语句

循环

for 循环

for 变量 in

序列:

语句1

语句2

技术分享图片

range

  • 生成一个数字序列

  • 范围:[m,n)

    # 打印 1~10 for i in range( 1 , 11

    ):

    print (i)

for-else

  • 当for循环结束的时候,会执行else语句

  • else语句可选

while 循环

while

条件表达式:

语句块

# 另外一种表达方法 while

条件表达式:

语句块1

else

语句块2

循环之break,continue,pass

  • break: 无条件结束整个循环,简称循环猝死

  • continue:无条件结束本次循环,从新进入下一轮循环

  • pass:表示略过,通常用于站位,没有跳过功能

六、函数

  • def关键字

  • 代码缩进

    # 定义 def

    func():

    print ( " 这是一个函数 "

    )

    # 调用 func()

函数的参数和返回值

  • 参数: 负责给函数传递一些必要的数据或者信息

    • 形参(形式参数): 在函数定义的时候用到的参数没有具体值,只是一个占位的符号,成为形参

    • 实参(实际参数): 在调用函数的时候输入的值

  • 返回值: 函数的执行结果

    • 使用 return 关键字

    • 如果没有 return ,默认返回一个 None

    • 函数一旦执行 return 语句,则无条件返回,即结束函数的执行

      # return语句的基本使用 # 函数打完招呼后返回一句话 def

      hello(person):

      print ( " {0}, 你肿么咧 "

      .format(person))

      print ( " Sir, 你不理额额就走咧 "

      )

      return " 我已经跟{0}打招呼了,{1}不理我 "

      .format(person, person)

      p

      = " 明月 " rst =

      hello(p)

      print (rst)

# 定义一个函数,打印一行九九乘法表 def

printLine(row):

for col in range( 1 , row + 1

):

# print函数默认任务打印完毕后换行 print ( row * col, end = " "

)

print ( ""

)

# 九九乘法表 # version 2.0 for row in range( 1 , 10

):

printLine(row)

参数详解

  • 参数分类

    • 普通参数

    • 默认参数

    • 关键字参数

    • 收集参数

  • 普通参数

    • 参见上例

    • 定义的时候直接定义变量名

    • 调用的时候直接把变量或者值放入指定位置

      def 函数名(参数1, 参数2,

      技术分享图片

      .):

      函数体

      # 调用 函数名(value1, value2,

      技术分享图片

      技术分享图片

      .)

  • 默认参数

    • 形参带有默认值

    • 调用的时候,如果没有对相应形参赋值,则使用默认值

      def func_name(p1 = v1, p2 = v2

      技术分享图片

      技术分享图片

      技术分享图片

      .):

      func_block

      # 调用1

      func_name()

      # 调用2 value1 = 100 value2 = 200 func_name(value1,value2)

  • 关键字参数

    def func(p1 = v1, p2 = v2

    技术分享图片

    ..):

    func_body

    # 调用函数: func(p1 = value1, p2 = value2

    技术分享图片

    技术分享图片

    .)

  • 收集参数

    • 把没有位置,不能和定义时的参数位置相对应的参数,放入一个特定的数据结构中

      def func( *

      args):

      func_body

      # 按照list使用方式访问args得到传入的参数 # 调用: func(p1, p2, p3,

      技术分享图片

      ..)

收集参数混合调用的顺序问题

  • 收集参数,关键字参数,普通参数可以混合使用

  • 使用规则就是,普通参数和关键字参数优先

  • 定义的时候一般找普通参数,关键字参数,收集参数 tuple,收集参数 dict

返回值

  • 函数和过程的区别

    • 有无返回值

  • 需要用return显示返回内容,

  • 如果没有返回,则默认返回None

递归函数

  • python对递归深度有限制,超过限制报错

    # 斐波那契额数列 # 一列数字,第一个值是1, 第二个也是1, 从第三个开始,每一个数字的值等于前两个数字出现的值的和 # 数学公式为: f(1) = 1, f(2) = 1, f(n) = f(n-1) + f(n-2) # 例如: 1,1,2,3,5,8,13.。。。。。。。。 # n表示求第n个数子的斐波那契数列的值 def

    fib(n):

    if n == 1

    :

    return 1 if n == 2

    :

    return 1 return fib(n - 1 ) + fib(n - 2

    )

    print (fib( 3

    ))

    print (fib( 10 ))

  • 汉诺塔问题

    • 规则:

    • 方法:

  1. n=1: 直接把A上的一个盘子移动到C上, A->C

  2. n=2:

  3. n=3:

  4. n = n:

  1. 把小盘子从A放到B上, A->B

  2. 把大盘子从A放到C上, A->C

  3. 把小盘子从B放到C上, B->C

  1. 把A上的两个盘子,通过C移动到B上去, 调用递归实现

  2. 把A上剩下的一个最大盘子移动到C上, A->C

  3. 把B上两个盘子,借助于A,挪到C上去, 调用递归

  1. 把A上的n-1个盘子,借助于C,移动到B上去,调用递归

  2. 把A上的最大盘子,也是唯一一个,移动到C上,A->C

  3. 把B上n-1个盘子,借助于A,移动到C上, 调用递归

  1. 每次移动一个盘子

  2. 任何时候大盘子在下面,小盘子在上面

def

hano(n, a, b, c):

‘‘‘

汉诺塔的递归实现

n:代表几个盘子

a:代表第一个塔,开始的塔

b:代表第二个塔,中间过渡的塔

c:代表第三个塔, 目标塔

‘‘‘ if n == 1

:

print (a, " --> "

, c)

return

None

‘‘‘

if n == 2:

print(a, "-->", b)

print(a, "-->", c)

print(b, "-->", c)

return None

‘‘‘ # 把n-1个盘子,从a塔借助于c塔,挪到b塔上去 hano(n - 1

, a, c, b)

print (a, " --> "

, c)

# 把n-1个盘子,从b塔,借助于a塔,挪到c塔上去 hano(n - 1 ,b, a, c)

a = " A " b = " B " c = " C " n = 1

hano(n, a, b, c)

n

= 2

hano(n, a, b, c)

n

= 3 hano(n, a, b, c)

查找函数帮助文档

  • 用 help 函数

    help( print )

  • 使用__doc__

    def

    stu(name, age):

    ‘‘‘

    这是文档的文字内容

    :param name: 表示学生的姓名

    :param age: 表示学生的年龄

    :return: 此函数没有返回值

    ‘‘‘ pass print

    (help(stu))

    print ( " * " * 20

    )

    print (stu. __doc__ )

七、变量作用域

  • 分类:按照作用域分类

    • 全局(global): 在函数外部定义

    • 局部(local):在函数内部定义

  • LEGB原则

    • L(Local)局部作用域

    • E(Enclosing function locale)外部嵌套函数作用域

    • G(Global module)函数定义所在模块作用域

    • B(Buildin): python内置魔抗的作用域

提升局部变量为全局变量(使用global)

def

fun():

global

b1

b1

= 100 print

(b1)

print ( " I am in fun "

)

# b2的作用范围是fun b2 = 99 print

(b2)

fun()

print (b1)

globals, locals函数

  • 可以通过globals和locals显示出局部变量和全局变量

    # globals 和 locals # globals 和 locals 叫做内建函数 a = 1 b = 2 def

    fun(c,d):

    e

    = 111 print ( " Locals={0} "

    .format(locals()))

    print ( " Globals={0} "

    .format(globals()))

    fun(

    100 , 200 )

eval()函数

  • 把一个字符串当成一个表达式来执行, 返回表达式执行后的结果

    eval(string_code, globals = None, locals = None)

exec()函数

跟eval功能类似, 但是,不返回结果

exec (string_code, globals = None, locals = None)

此篇文章献给还处于Python零基础的小白们!保证你能入门不是问题

标签:特征   数据转换   dex   出现   exe   获取   偶数   调用函数   创建   

原文地址:https://www.cnblogs.com/Python1234/p/9064427.html

(0)
(0)
   
举报
评论 一句话评论(0
登录后才能评论!
© 2014 mamicode.com 版权所有  联系我们:gaon5@hotmail.com
迷上了代码!