澳门新萄京官方网站-www.8455.com-澳门新萄京赌场网址

澳门新萄京官方网站:python3主干语法,学习笔记

2019-06-30 作者:www.8455.com   |   浏览(76)
  • 元组相加

    t1 = (1,2,3) t2 = (4,5,6)

    print(id(t1)) print(id(t2))

    t1 = t2 #即t1=t1 t2,将t1与t2元组相加,t1指向相加之后的新元组,该操作合法,因为成分内容无法修改,可是能够针对新的地点

    print(t1) print(id(t1)) #相加之后的t1指向一个新的地点

  • 变量

Python 3.6

1.执行python脚本的二种方式:

答:1、./run.py.shell直接调用python脚本

2、python run.py 调用python 解释器来调用python脚本

 

copy深浅拷贝,copy深浅

 

  我们在相当的多措施里都看看copy()方法,那是对变量的复制,赋值,下边来看一下实例:

    大家能够让二个变量等于另一个变量能够采纳赋值的办法,例如a = b等,让变量a = b变量,还足以经过copy()来贯彻。下边来看望在各类情状下的关系意况:

    一、字符串和数字的情事

    >>> import copy
  >>> a = 3
  >>> b = a
  >>> c = copy.copy(a)
  >>> d = copy.deepcopy(a)
  >>> b
  3
  >>> c
  3
  >>> d
  3
    >>> print(id(a),id(b),id(c),id(d))
  10914432 10914432 10914432 10914432
    从下边能够见到,大家透过导入模块copy,那么些模块特意用来复制,可以看到在数字中,选取赋值、copy()、deepcopy()三种办法,大家开采采取二种艺术的秘技,都以把地方关联过去,具备一样的地址,表达是选取如下格局展开保管的。实举例下:

    澳门新萄京官方网站 1

    从上海体育场所能够看看,在数字和字符串中,两种任意方式都以关系到字符串或数字所在的内部存款和储蓄器,是把内容涉及过去,因而无论使用这种办法都是一致的

。上面来看一看在列表,元组、字符串、字典中的意况。

二、列表,元组,字典一层复制意况

    列表、字典的情事

    1、在列表中的情况

    import copy
  l = ["alex",11,"sb","tom"]
  d = {"k1":"v1","k2":22,"k3":"alex"}
  t = (11,'ALEX',"sb")

  l1 = l
  l2 = copy.copy(l)
  l3 = copy.deepcopy(l)

  print(id(l),id(l1),id(l2),id(l3))

  #下边来修改一下列表中的成分,看看关联意况编制程序什么样了,如下:
  l.append("Aoi")
  print(l,l1,l2,l3)
  print(id(l),id(l1),id(l2),id(l3))
    2、在字典中的情况
  d1 = d
  d2 = copy.copy(d)
  d3 = copy.deepcopy(d)
  print(id(d),id(d1),id(d2),id(d3))
  d.__setitem__("tom","Hello")
  print(d,"n",d1,"n",d2,"n",d3)
  print(id(d),id(d1),id(d2),id(d3))

  运维结果如下:

    列表中的运算结果:

    140006457636360 140006457636360 140006457672456 140006457637320
  ['alex', 11, 'sb', 'tom', 'Aoi'] ['alex', 11, 'sb', 'tom', 'Aoi'] ['alex', 11, 'sb', 'tom'] ['alex', 11, 'sb', 'tom']
  140006457636360 140006457636360 140006457672456 140006457637320
  140006482186568 140006482186568 140006457674440 140006457636680
  字典中的运算结果:

    {'k2': 22, 'k3': 'alex', 'tom': 'Hello', 'k1': 'v1'}
  {'k2': 22, 'k3': 'alex', 'tom': 'Hello', 'k1': 'v1'}
   {'k2': 22, 'k1': 'v1', 'k3': 'alex'}
  {'k2': 22, 'k1': 'v1', 'k3': 'alex'}
  140006482186568 140006482186568 140006457674440 140006457636680

    能够见到,在列表中我们通过等号赋值(=)、copy(list)、deepcopy(list)方法打字与印刷变量的ip地址,能够看到,等号赋值(=)与原先变量的地点是均等的,因而等号的赋值格局是那样的:

    澳门新萄京官方网站 2

    等号赋值无论在事关字典依旧列表的经过中,都以指向同五个Python开垦的内部存款和储蓄器地址,a和b的内部存款和储蓄器地址永世是同等的,只要a产生了扭转,相应的b就发生变化。

    而在字典中copy()和deepcopy()确是上边包车型客车款型:

    澳门新萄京官方网站 3

 

    为何自身估量copy()是地点的花样呢,大家来看一段代码:

    import copy
  l = ["alex",11,"sb","tom"]
  d = {"k1":"v1","k2":22,"k3":"alex"}                                   (1)
  t = (11,'ALEX',"sb")

  l1 = l
  l2 = copy.copy(l)
  l3 = copy.deepcopy(l)

  print(id(l),id(l1),id(l2),id(l3))

  #上边来修改一下列表中的元素,看看关联处境编程什么样了,如下:
  l.append("Aoi")
  print(l,l1,l2,l3)
  print(id(l),id(l1),id(l2),id(l3))

  d1 = d
  d2 = copy.copy(d)                                        (2)
  d3 = copy.deepcopy(d)
  print(id(d),id(d1),id(d2),id(d3))                        (3)
  d.__setitem__("tom","Hello")
  print(d,"n",d1,"n",d2,"n",d3)
  print(id(d),id(d1),id(d2),id(d3))                         (4)

  del d["k1"]                                               (5)
  print(d,"n",d1,"n",d2,"n",d3)
  print(id(d),id(d1),id(d2),id(d3))                          (6)

    代码运营如下:

    140353118074376 140353118074376 140353118110472 140353118074760
  ['alex', 11, 'sb', 'tom', 'Aoi'] ['alex', 11, 'sb', 'tom', 'Aoi'] ['alex', 11, 'sb', 'tom'] ['alex', 11, 'sb', 'tom']
  140353118074376 140353118074376 140353118110472 140353118074760
  140353142624584 140353142624584 140353118112456 140353118075272
  {'k1': 'v1', 'tom': 'Hello', 'k2': 22, 'k3': 'alex'}
   {'k1': 'v1', 'tom': 'Hello', 'k2': 22, 'k3': 'alex'}
   {'k1': 'v1', 'k2': 22, 'k3': 'alex'}
   {'k1': 'v1', 'k2': 22, 'k3': 'alex'}
  140353142624584 140353142624584 140353118112456 140353118075272
  {'tom': 'Hello', 'k2': 22, 'k3': 'alex'}
   {'tom': 'Hello', 'k2': 22, 'k3': 'alex'}
   {'k1': 'v1', 'k2': 22, 'k3': 'alex'}
   {'k1': 'v1', 'k2': 22, 'k3': 'alex'}
  140353142624584 140353142624584 140353118112456 140353118075272

    在地点(1)处我们定义了七个字典,在(2)处大家运用copy.copy()发生一个新的变量d2,然后大家打印变量d、d2的id(d)、id(d2),大家能够见见,两个的id()是不雷同的,由此得以作证在系统中是存在了五个岗位存放d和d2的,而不是一个任务,仅凭那或多或少还不足以证实,下边来看(5)处,大家删除了字典d中的键-值对"k1",此时只要两个存在涉嫌的话,那么d第22中学键-值对"k1":"v1"必然也会被删去,事实上并不曾,而且大家修改元素的时候,借使它们中间存在指向关系的话,那么copy()也会让d第22中学的增多三个键-值对"tom":"Hell0"。事实上并不曾,所以作者确定,无论如何使用copy()方法都是在内部存储器中新开荒了一个地方,要是唯有一层的话,那多少个地方之间也是尚未关系的。

    借使字典唯有一层,那么使用deepcopy()方法也是如出一辙的,图比方下:

    澳门新萄京官方网站 4

 

三、列表,元组,字典多层情状的赋值情形

   上面大家商讨了copy()、deepcopy()单层的处境,上边来看望多层的情形,首先定义多个字典n1={"k1":123,"k2":"wupie","k3":[123,"alex"]}

,

 

澳门新萄京官方网站 5

     在python中,copy()、deepcopy()的安装挺复杂的,一样成分的id是同样的,不过在剔除的时候又不会影响由copy()、deepcopy()爆发的变量,

唯独在利用copy()的时候,第二层的因素仍然与原来的要素关联在协同,上边来看三个例证:

    import copy

  n1 = {"k1":123,"k2":"wupie","k3":[456,"alex"]}

  #打印k1的ip地址
  n2 = copy.copy(n1)
  n3 = copy.deepcopy(n1)

  print(n1,"n" ,n2,"n",n3)
  print(id(n1),id(n2),id(n3))
  print(id(n1["k1"]),id(n2["k1"]),id(n3["k1"]),"n")

  #打印k2的地址
  print(id(n1["k2"]),id(n2["k2"]),id(n3["k2"]),"n")

  #打印"k3"的ip地址
  print(id(n1["k3"]),id(n2["k3"]),id(n3["k3"]),"n")

  #修改“k1"的值
  n1["k1"] = 888

  #打字与印刷修改后的音讯
  print(n1,"n" ,n2,"n",n3)
  print(id(n1),id(n2),id(n3))
  print(id(n1["k1"]),id(n2["k1"]),id(n3["k1"]),"n")

  #打字与印刷修改后的k2的地方
  print(id(n1["k2"]),id(n2["k2"]),id(n3["k2"]),"n")

  #打印"k3"的ip地址
  print(id(n1["k3"]),id(n2["k3"]),id(n3["k3"]),"n")

  #修改"k3"中的值
  n1["k3"][0] = 666
  print(n1,"n" ,n2,"n",n3)
  print(id(n1),id(n2),id(n3))
  print(id(n1["k1"]),id(n2["k1"]),id(n3["k1"]),"n")

  #打字与印刷修改后的k2的地点
  print(id(n1["k2"]),id(n2["k2"]),id(n3["k2"]),"n")

  #打印"k3"的ip地址
  print(id(n1["k3"]),id(n2["k3"]),id(n3["k3"]),"n")

  #删除"k3"的键值对
  del n1["k3"]
  print(n1,"n" ,n2,"n",n3)
  print(id(n1),id(n2),id(n3))print(id(n1["k1"]),id(n2["k1"]),id(n3["k1"]),"n")

  #打字与印刷修改后的k2的地方

  print(id(n1["k2"]),id(n2["k2"]),id(n3["k2"]),"n")

  try:#打印"k3"的ip地址

    print(id(n1["k3"]),id(n2["k3"]),id(n3["k3"]),"n")

  except KeyError:

     print(id(n2["k3"]),id(n3["k3"]))id(n2),id(n3))print(id(n1["k1"]),id(n2["k1"]),id(n3["k1"]),"n")#打印修改后的k2的地点print(id(n1["k2"]),id(n2["k2"]),id(n3["k2"]),"n")try:#打印"k3"的ip地址 print(id(n1["k3"]),id(n2["k3"]),id(n3["k3"]),"n")except KeyError: print(id(n2["k3"]),id(n3["k3"]))

    运转结果如下:

    {'k3': [456, 'alex'], 'k1': 123, 'k2': 'wupie'}
   {'k3': [456, 'alex'], 'k1': 123, 'k2': 'wupie'}
  {'k3': [456, 'alex'], 'k1': 123, 'k2': 'wupie'}
  139928164286856 139928139772744 139928139736968
  10918272 10918272 10918272

  139928163731640 139928163731640 139928163731640

  139928139736520 139928139736520 139928139737608           (k3)的ip地址

  {'k3': [456, 'alex'], 'k1': 888, 'k2': 'wupie'}
   {'k3': [456, 'alex'], 'k1': 123, 'k2': 'wupie'}
   {'k3': [456, 'alex'], 'k1': 123, 'k2': 'wupie'}
  139928164286856 139928139772744 139928139736968
  139928164089648 10918272 10918272

  139928163731640 139928163731640 139928163731640

  139928139736520 139928139736520 139928139737608

  {'k3': [666, 'alex'], 'k1': 888, 'k2': 'wupie'}
   {'k3': [666, 'alex'], 'k1': 123, 'k2': 'wupie'}
   {'k3': [456, 'alex'], 'k1': 123, 'k2': 'wupie'}
  139928164286856 139928139772744 139928139736968
  139928164089648 10918272 10918272

  139928163731640 139928163731640 139928163731640

  139928139736520 139928139736520 139928139737608

  {'k1': 888, 'k2': 'wupie'}
   {'k3': [666, 'alex'], 'k1': 123, 'k2': 'wupie'}
   {'k3': [456, 'alex'], 'k1': 123, 'k2': 'wupie'}
  139928164286856 139928139772744 139928139736968
  139928164089648 10918272 10918272

  139928163731640 139928163731640 139928163731640

  139928139736520 139928139737608

    在下面例子中,大家率先定义了三个变量n1,里面嵌套了一层字典,然后选用copy(),deepcopy()生成了新的变量n2,n3并且打字与印刷了n1,n2,n3的ip地址,由ip地址能够看看,n1,n2,n3是在内存中有例外的蕴藏地方的,接着大家打字与印刷了键-值对“k1”的储存id,结果发掘,三者的“k1”存款和储蓄的id地点是一模一样的,表明只怕用的本来职位的id,这样节约了内部存款和储蓄器,接着大家看“k3”的ip地址,能够看来,使用copy()得到的ip地址与n1的“k3”的id是均等的,表明是用的一个id,大家修改字典n第11中学的成分"k3"之后,n2也随着变动,表达字典n第11中学的“k3”和字典n第22中学的“k3”存在某种管理,然则当大家删除字典n1中的“k3”之后,字典n第22中学的"k3"不受影响,还留存,表达使用copy()生成的变量,第二层关系之间存在着某种关联,不过又不完全依存,第一层之间共用一个地址,节省了内部存款和储蓄器,可是在本来的字典产生变化的时候又不影响此前的变量,只是对新的变量开发了四个空间,用来存放地点。

   

 

 

澳门新萄京官方网站 6

 

澳门新萄京官方网站 7

 

    有一个监督检查模板,包蕴内部存款和储蓄器,硬盘,有一堆机器,今后是按dic情势运行的,未来要修改在那之中有的的及其的硬盘,其余一些不退换。

    import copy
  dic = {
  "cpu":[80,],
  "men":[80,],
  "disk":[80]
  }

  print("before:",dic)
  new_dic = copy.deepcopy(dic)
  new_dic["cpu"][0] = 50

  print(dic,"n",new_dic)

    在上头,我们利用copy模块的deepcopy来伸开拍卖,大家知道,有那个消息,在嵌套中,唯有deepcopy()才会转移第二层的音讯。

大家在十分的多主意里都见到copy()方法,那是对变量的复制,赋值,上边来看一下实例: 大家可以让二个变量等于另三个...

 输出为

python通过=进行变量赋值,证明变量时无需注明数据类型

运算符

  • - * / 四则运算 % 求余 **乘方
  • // 用于整除

5.python单行注释和多行注释分别是何等?

 答:单行注释用#,多行注释用三引号

2583036379208
2583036379280
(1, 2, 3, 4, 5, 6)
2583035574600
#-*- coding:utf -8-*-
#/usr/bin/python3

#在声明变量时不需要声明变量类型

counter = 100        #整型变量  

miles = 1000.0       #浮点型变量

name = "runobb"   #字符串 

#打印变量:print()

print(counter)

print(miles)

print(name)

#查看数据类型:type()

print(type(counter))

print(type(miles))

print(type(name))

#同时为多个变量赋值
#创建一个整型对象,值为1,三个变量被分配到相同的内存空间
a = b = c = 1
#id()查看该变量的内存空间地址

字符串

  • 字符串用单引号或双引号括起来。
  • 三引号(单引号或双引号均可)表示多行字符串,行末加反斜杠表示换行不算在字符串之内。
  • 字符串加上前缀 r 表示原生字符串。
  • 用于连接字符串。
  • * 用于重复字符串。
  • 相邻的字符串字面量会自动三番五次。
  • 字符串存在一些(slice)语法(使用下标获取子串),但字符串自个儿不可变。
  • 一对语法中下标 0 指向第三个要素,下标 -1 指向最终多个成分。

    'a' * 3 'aaa' 'b' 'a' 'ba' 'b' "a" 'ba' print(r'C:somename') C:somename print(""" a b c """) a b c "abcde"[1:] 'bcde' "abcde"[:4] 'abcd' "abcde"[:] 'abcde' "abcde"[-3:] 'cde'

6.声称变量注意事项有怎么着?

 答:1.变量名只可以是数字、字母、下划线的任性组合

2.变量名的首先个字符不能为数字

3.python重要字不能用作变量名

  •  元组相乘

    t1 = (1,2,3) print(id(t1)) t1 = t1 * 3 #运算之后生成新的元组,t1指向所生成的因素新鸿基土地资金财产方 print(t1) #输出(1, 2, 3, 1, 2, 3, 1, 2, 3) print(id(t1)) #t1指向了三个新的地方

  •  双层元组的遍历

    t = ((1,2,3),(6,7,8),("i","love","you")) for i in t:

    print(i)
    

    print(""20)

    for k,v,w in t:

    print(k,"...",v,"...",w)
    

In [16]: print(id(a))
1658082080

列表(Lists)

  • 列表:一种成员的花色一样但个数不限的数据结构。
  • 列表选拔中括号加逗号的独特语法。
  • 连接五个列表。
  • 列表存在部分(slice)语法(使用下标获取子列表),列表片段可变(能够由此赋值被替换)。
  • 部分语法中下标 0 指向第八个成分,下标 -1 指向最后四个成分。

    [1,2,3][1:] [2, 3] [1,2,3][-2:] [2, 3] a = [1,2,3,4] a[2:] = [4,5,6] a [1, 2, 4, 5, 6] a[2:] = [] a [1, 2]

  • append 方法添英镑素。

  • extend 方法连接另三个列表。
  • insert 方法插入成分。
  • remove 方法移除钦赐成分。
  • pop 方法弹出最终面的因素。
  • clear 方法清空驶列车表。
  • index 方法寻觅钦定成分的下标。
  • count 方法重回列表的尺寸。
  • reverse 方法翻转列表。
  • copy 方法复制列表。

    fruits = ['orange', 'apple', 'pear', 'banana', 'kiwi', 'apple', 'banana'] fruits.count('tangerine') 0 fruits.index('banana') 3 fruits.reverse() fruits ['banana', 'apple', 'kiwi', 'banana', 'pear', 'apple', 'orange'] fruits.sort() fruits ['apple', 'apple', 'banana', 'banana', 'kiwi', 'orange', 'pear']

  • 列表解析(List Comprehensions)

    [x**2 for x in range(10)] [0, 1, 4, 9, 16, 25, 36, 49, 64, 81] [(x, y) for x in [1,2,3] for y in [3,1,4] if x != y] [(1, 3), (1, 4), (2, 3), (2, 1), (2, 4), (3, 1), (3, 4)]

8.如何查看变量在内部存款和储蓄器中的地址?

答:用id(变量名) 就能够查看变量在内存中的地址

 

 输出为

In [17]: print(id(b))
1658082080

元组(Tuples)

  • 元组:一种成员数量和次序固定但项目不尽同样的数据结构。
  • 元组选择小括号加逗号的出格语法。(最外层元组的小括号可粗略)
  • 元组是不可变的。
  • 元组存在下标语法。
  • 存在未有别的成员的元组 () 以及唯有二个分子的元组 a, (成分后跟三个逗号表示元组)

    t = 123,"123" t[0] 123 t[1] '123' u = t, 456 u ((123, '123'), 456) v = 1, v (1,)

9.实践python程序时,自动生成的.pyc文件的魔法是何许?

答:pyc是一种二进制文件,是由py文件通过编译后,生成的文件,是一种byte code,py文件形成pyc文件后,加载的进程有所进步,而且pyc是一种跨平台的字节码,是由python的设想机来举办的,py文件是足以一向观望源码的,所以就需求编写翻译为pyc后,再发表出去,实现部分源码的隐藏.

(1, 2, 3)
(6, 7, 8)
('i', 'love', 'you')
********************
1 ... 2 ... 3
6 ... 7 ... 8
i ... love ... you

In [18]: print(id(c))
1658082080

解构语法

>>> a,b = [1,2]
>>> a,b
(1, 2)
>>> a,b = (1,2)
>>> a,b
(1, 2)
>>> a,b = b,a
>>> a,b
(2, 1)

10.写代码

  •  八个变量调换

    a = (1,2,3) b = (7,8,9) print(a) #输出(1, 2, 3) print(b) #输出(7, 8, 9) print(""20) a,b = b,a #四个元组调换,一样适用于其余种种型变量(例如int,list等等) print(a) #输出(7, 8, 9) print(b) #输出(1, 2, 3)

  • 数值运算

集合(Sets)

  • 会师:一种不设有重复成分的哈希表数据结构。
  • 集聚选择大括号加逗号的超过常规规语法。
  • 常用操作包含求差集,并集,交集,对称差集。
  • 留存集合的辨析表达式。(set comprehensions)

    basket = {'apple', 'orange', 'apple', 'pear', 'orange', 'banana'} basket {'pear', 'orange', 'banana', 'apple'} a = set('abracadabra') b = set('alacazam') a {'c', 'a', 'r', 'd', 'b'} b {'l', 'c', 'a', 'm', 'z'} a - b # 差集 {'b', 'd', 'r'} a | b # 并集 {'m', 'l', 'c', 'a', 'r', 'd', 'b', 'z'} a & b # 交集 {'c', 'a'} a ^ b # 对称差集 {'d', 'b', 'l', 'm', 'z', 'r'} {x for x in 'abracadabra' if x not in 'abc'} {'d', 'r'}

a.兑现用户输入用户名和密码,当用户名叫seven且密码为123时,展现登入成功,否则显示登入战败.

 

name=input("请输入用户名:").strip()
pwd=input("请输入密码:").strip()
if name=="seven" and pwd=="123":
    print("登陆成功")
else:
    print("登陆失败")

 

 

 

 

字典(Dictionaries)

  • 字典:一种存放键值对的哈希表数据结构。
  • 字典采纳大括号加冒号和逗号的出格语法。
  • 留存字典的深入分析表明式。(dictionary comprehensions)

    澳门新萄京官方网站:python3主干语法,学习笔记。tel = {'jack': 4098, 'sape': 4139} tel {'jack': 4098, 'sape': 4139} tel['jack'] 4098 tel['guido'] = 4127 tel {'jack': 4098, 'sape': 4139, 'guido': 4127} {x: x**2 for x in (2, 4, 6)} {2: 4, 4: 16, 6: 36}

b.实现用户输入用户名和密码,当用户名叫seven且密码为123时,呈现登入成功,不然彰显登录退步.退步时允许再一次输入3次

count=0
while count<3:
    count =1
    name=input("请输入用户名:").strip()
    pwd=input("请输入密码:").strip()
    if name=="seven" and pwd=="123":
      print("登陆成功")
      break
    else:
        print("登陆失败")
        continue

 

>>>5   4  # 加法
9
>>> 4.3 - 2 # 减法
2.3
>>> 3 * 7  # 乘法
21
>>> 2 / 4  # 除法,得到一个浮点数
0.5
>>> 2 // 4 # 除法,得到一个整数
0
>>> 17 % 3 # 取余 
2
>>> 2 ** 5 # 乘方
32

range 函数

>>> list(range(5,10))
[5, 6, 7, 8, 9]
>>> list(range(0,10,3))
[0, 3, 6, 9]
>>> list(range(-10,-100,-30))
[-10, -40, -70]

c.达成用户输入用户名和密码,当用户名字为seven且密码为123时,呈现登录成功,不然显示登入战败.失利时允许再一次输入3次

 

 

count=0
while count<3:
    count =1
    name=input("请输入用户名:").strip()
    pwd=input("请输入密码:").strip()
    if name=="seven"or name=="alex" and pwd=="123":
      print("登陆成功")
      break
    else:
        print("登陆失败")
        continue

 

注意:

语句

  • while 语句
  • for 语句(实质上是 foreach)
  • if ... elif ... else 语句
  • 代码块选用冒号加缩进来表示
  • pass 语句(空语句)
  • break continue 语句
  • 循环 else语句(表示循环符合规律停止,没有被 break)

    for n in range(2, 10): for x in range(2, n): if n % x == 0: print(n, 'equals', x, '*', n//x) break else: print(n, 'is a prime number')

2 is a prime number
3 is a prime number
4 equals 2 * 2
5 is a prime number
6 equals 2 * 3
7 is a prime number
8 equals 2 * 4
9 equals 3 * 3

11.写代码

  1. python可以同期为八个变量赋值如 a , b = 1 , 2
  2. 三个变量能够通过赋值指向差异档期的顺序的靶子
  3. 数值的除法(/)总是回到叁个浮点数,要拿走整数使用(//)操作符
  4. 在混合计算时,python会把整型转变为浮点型

函数

  • 概念函数使用 def。
  • 形参的独竖一帜形式有:带缺省值的形参 arg=value,元组形参 *澳门新萄京官方网站,args,字典形参 **args。
  • 实参的特别规情势有:带关键字的实参 kwarg=value,列表/元组实参 *args,字典实参 **args。

    def f(a, b=2): # 带缺省值的形参 print(a,b)

    f(3) 3 2 f(a=4) # 带关键字的实参 4 2 d = {"a":3,"b":5} f(d) # 字典实参,调用时展开3 5 def f(k, *args, kws): # 元组形参,字典形参 print(k) for arg in args: print(arg) for kw in kws: print(kw, ":", kws[kw])

>>> f("a", 1,2,3, c=4,d="abc") # 调用时 1,2,3 打包成元组,c=4,d="abc" 打包成字典
a
1
2
3
c : 4
d : abc
>>> args = [3,6]
>>> list(range(*args)) # 列表实参,调用时展开
[3, 4, 5]
>>> args = (3,6)
>>> list(range(*args)) # 元组实参,调用时展开
[3, 4, 5]

a.选择while循环输出2-3 4-5 6.. 100的和

count=1
s=0
while count<100:
    count =1
    s =(-1)**count*count
print(s)

 

  • 字符串(String)

    1 #-- coding:utf-8 -- 2 #!/usr/bin/python3 3 4 str = "keatiuny" 5 print(str) #打字与印刷变量str 6 print(str[0]) #通过下标的艺术获取str中对应的value,0:第二个值 -1:最后二个 7 print(str[0:3]) #获得str中首先位到第二个人的中间的值(不含有第三位) 8 print(str[0:-1]) #获得str中第一个人到终极一人中间的值,不分包最终壹个人 9 print(str*2) #打字与印刷2次 10 print(str "name") #拼接字符串 11 12 #输出结果 13 keatiuny 14 k 15 kea 16 keatiun 17 keatiunykeatiuny 18 keatiunyname

b.使用for循环和range实现1-2 3-4 5-6... 99的和

s=0
for i in range(1,100):
    s =-(-1)**i*i
print(s)

 

 

注意:

C.使用while循环输出1,2,3,4,5  7,8,9  11,12

count=0
while count<12:
    count =1
    if count==6 or count==10:
        continue
    print(count,end=" ")

 

 

  1. 反斜杠能够用来转义,使用r能够让反斜杠不产生转义 例: print(r'Runoob'),输出结果中隐含
  2. 字符串能够用 连接在一块儿,用 * 重复
  3. python中字符串不能够更动

d.使用while循环输出1-100内的具备基数

count=0
while count<100:
    count =1
    if count%2!=0:
        print(count)

 

  • 列表(list):

e.使用while循环输出1-100内的具有偶数

count=0
while count<100:
    count =1
    if count%2==0:
        print(count)

 

11.**分别书写数字5,10,32,7的二进制

**

#5=2**2 2**0
#5对应的二进制为 101
print(bin(5))

#10=2**3 2**1
#10对应的二进制为1010
print(bin(10))

#32=2**5
#32对应的二进制为100000
print(bin(32))

#7=2**2 2**1 2**0
#7对应的二进制 111
print(bin(7))

 

 

list是python中采取最频仍的数据类型

14.今昔有如下多少个变量,请简述n1和n2是如何关系?

n1=123

n2=123

答: n1和n2的id(内部存款和储蓄器地址) 值 和type都拾叁分

 

list中元素的项目能够差异等,list扶助数字、字符串、嵌套列表

15.以后有如下多个变量,请简述n1和n2是怎么关系?

n1=123456

n2=123456

答:n1和n2的id(内部存款和储蓄器地址)不等 type差异,值一样,分别指向八个同样的数值123456

list = ['keatiuny',1,'1.15']            #多个value的可变的集合,是一个可迭代对象
list2 = ['hello python',456]
#切片
print(list)                 #打印整个list
print(list[0])              #取list中第一个value
print(list[0:2])            #取list中0:2的值(不包含2)
print(list[-1])             #取list中最后一个值
print(list[0:])             #取整个list中的值

#遍历list
#方法一:for循环
for value in list:
    print(value)
#方法二:while 循环:
i = 0
while i < len(list):
    print(list[i])
    i  = 1
#对list的操作(增删改查)
"""
列表操作包含以下函数:
1、cmp(list1, list2):比较两个列表的元素 
2、len(list):列表元素个数 
3、max(list):返回列表元素最大值 
4、min(list):返回列表元素最小值 
5、list(seq):将元组转换为列表 
列表操作包含以下方法:
1、list.append(obj):在列表末尾添加新的对象
2、list.count(obj):统计某个元素在列表中出现的次数
3、list.extend(seq):在列表末尾一次性追加另一个序列中的多个值(用新列表扩展原来的列表)
4、list.index(obj):从列表中找出某个值第一个匹配项的索引位置
5、list.insert(index, obj):将对象插入列表
6、list.pop(obj=list[-1]):移除列表中的一个元素(默认最后一个元素),并且返回该元素的值
7、list.remove(obj):移除列表中某个值的第一个匹配项
8、list.reverse():反向列表中元素
9、list.sort([func]):对原列表进行排序
"""

16.今昔有如下多少个变量,请简述n1和n2是怎么着关系?

 n1=123456

 n2=n1

 

答:n1和n2的id(内部存款和储蓄器地址) 值 和type都万分

  • 元组(tuple)

17.一旦有贰个变量n=5,请使用int提供的点子,获得该变量最少能够用略带个二进制表示?

n=5
print(n.bit_length())

 

元组同list基本相似,只是元组一旦生完了不能转移,不能够改改增加和删除改,能够查

18.布尔值分别有何样?

答:布尔值有True和False

留心:定义当定义的元组中只有贰个元素时,供给在要素的前面增添逗号  tup1 = (20,)

19.澳门新萄京官方网站:python3主干语法,学习笔记。读书代码,写出施行结果:

a="alex"
b=a.capitalize()
print(a)
print(b)

 

答:alex  Alex

20.写代码,有如下代码,按需求达成各种效率:

name=" aleX"

__author__ = 'Administrator'
name=" aleX"
#a.移除两边对应的空格,并输入移除后的内容
print(name.strip())
#b.判断name变量对应的值是否以“al”开头,并输出结果
print(name.startswith("al"))
#c.判断name变量对应的值是否以“X”结尾,并输出结果
print(name.endswith("X"))
#d.将name变量值中的“l”替换为“p‘并输出结果
print(name.replace("l","p"))
#e.将name变量对应的值根据”l“切分,并输出结果
print(name.split("l"))
#f.上一题e中分割之后的值是什么类型
print(type(name.split("l")))
#g.将name变量对应的值变为大写,并输出值
print(name.upper())
#h.将name变量对应的值变为小写,并输出值
print(name.lower())
#i请输出name变量对应的值的第二个字符
print(name[1])
#j请输出name变量对应的值的前3个字符
print(name[:3])
#k请输出name变量对应的值的后2个字符
print(name[-2:])
#l 请输出name变量对应的值中”e“所在的索引位置
print(name.index("e"))

 

 

 

  • 字典(dic)
  • 集合(set)

21.字符串是不是足以迭代,假若得以请使用否循环迭代每多少个要素。

答:可以的

a="abcdefg"
for i in range(len(a)):
    print(a[i])

集合(set)是一个冬日不重复的元素集结。

22.写代码,按须要贯彻效果与利益

__author__ = 'Administrator'
li=["alex","erin","rain","aa","bb","cc"]
#a.计算列表的长度并输出
print(len(li))
#b.列表中追加元素”seven“,并输出添加后的列表
li.append("seven")
print(li)
#c.请在列表的第一个位置插入元素”tony“,并输出添加后的列表
li.insert(0,"Tony")
print(li)
#d.请修改列表第二个元素为"kelly",并输出修改后的列表
li[1]="kelly"
print(li)
#e.请删除列表中的”eric“,并输出修改后的列表
li.remove("erin")
print(li)
#f.删除列表的第二个元素,并输出删除的元素和删除后的列表
aa=li.pop(1)
print(aa)
print(li)
#g请删除列表中的第三个元素,并输出删除后的列表
li.pop(2)
print(li)
#h.请删除列表中的第2-4个元素,比输出删除后的列表
li.pop(1)
li.pop(1)
li.pop(1)
print(li)
#i将列表所有元素反转,并输出反转后的列表
li.reverse()
print(li)
#j请使用for in range 输出列表的索引
for i  in range(len(li)):
    print(i)
#k请使用enumberate输出列表元素和序号(序号从100开始)
for i,j in enumerate(li,start=100):
    print(i,j)
#l请使用for循环输出所有元素
for i in  li:
    print(i)

 

能够使用{  }可能set( )函数创设集合

23.写代码,按须要落到实处际效果果与利益:

li=["hello","seven",["moon",["h","kelly"],"all"],123,456]

__author__ = 'Administrator'
li=["hello","seven",["moon",["h","kelly"],"all"],123,456]
#a.请输出kelly
print(li[2][1][1])
#b.请使用索引找到”all”元素,并将其修改为“ALL”
print(li[2][2].upper())

 

)

  • 数据类型调换

24.写代码,有上边元组.按要求达成效果与利益

 

__author__ = 'Administrator'
tu=("alex","eric","rain")
#a.计算元组长度并输出
print(len(tu))
#b.获取元组的第二个元素,并输出
print(tu[1])
#c.获取元组的第1-2个元素,并输出
print(tu[:2])
#d.请使用for循环输出元组的元素
for i in tu:
    print(i)
#e.请使用 for len range 输出元组的索引
for i in range(len(tu)):
    print(i)
#f使用enumberate输出元组的元素和序号。序号从10开始
for i,j in  enumerate(tu,10):
    print(i,j)

 

 

25 有如下元组,按供给落到实处以下职能

tu=("alex",[11,22,{"k1":"v1","k2":["age","name"],"k3":(11,22,33)},44])

 

a.陈述元组的性格:

答:1、有序的群集,能够存放五个值

2、通过偏移来取多少

3、属于不可变的靶子,不能够在修改内容

b.元组里的第二个成分”alex”能够不可能修改?

答:不能修改

C.tu中的成分k2对应的值是什么品种,好不佳修改,如若能修改,则向其丰盛多少个要素seven。

答:k2对应的值是list(列表).能够修改

tu=("alex",[11,22,{"k1":"v1","k2":["age","name"],"k3":(11,22,33)},44])
print(tu[1][2]["k2"])
print(type(tu[1][2]["k2"]))
tu[1][2]["k2"].append("seven")
print(tu)

 

 

d.tu中的成分k3对应的值是何许项目,行还是不行修改,假使能修改,则向其充裕贰个因素seven。

答:k3对应的值类型是元组,不能修改

 

26字典

dic={"k1":"v1","k2":"v2","k3":[11,22,33]}

__author__ = 'Administrator'
dic={"k1":"v1","k2":"v2","k3":[11,22,33]}
#a.请循环输出所有key
for k in  dic:
    print(k)
#b.请循环输出所有value
for v in dic.values():
    print(v)
#c.请循环输出所有key,value
for k,v in dic.items():
    print(k,v)
#d.请在字典中添加一个键值对k4,v4,输出添加后的字典
dic["k4"]="v4"
print(dic)
#e.请修改字典中k1对应的值为alex,输出修改过后的字典
dic["k1"]="alex"
print(dic)
#f.请在k3对应的值中添加一个元素44,输出修改后的字典
dic["k3"].append(44)
print(dic)
#g.请在k3对应的值的第一个位置插入18,输出修改后的字典
dic["k3"].insert(0,18)
print(dic)

 

 

 

27 转换

#1.将字符串s=”alex”,转换成列表

s="alex"
l=list(s)
print(l)

#2.将字符串s=”alex”,转换成元组

s="alex"
t=tuple(s)
print(t)



#3.将列表li=[“selx”,”seven”]转换成元组

l=["alex","seven"]
t=tuple(l)
print(t)



#4.将元组tu=(“alex”,”seven”)转换成列表

t=("alex","seven")
l=list(t)
print(l)



#5..将列表li=[“selx”,”seven”]转换成字典且字典的key按照10开始向后递增



l=["alex","seven"]
d={}
for i,j in enumerate(l,start=10):
    d[i]=j
print(d)

 

28.求1-100装有的和

s=0
for i in range(1,101):
     s =i
print(s)

 

29.成分分类

有如下集结[11,22,33,44,55,66,77,88,99],将赶上66的位于集结的第4个key中,小于66的放在集合的第二个key中

l=[11,22,33,44,55,66,77,88,99]
d={"k1":[],"k2":[]}
for i in l:
    if i>66:
        d["k1"].append(i)
    elif i<66:
        d["k2"].append(i)
print(d)

 

 

 

 

30.购物车

功效须要:

   要求用户输入总资金:如三千

   展现商品列表;用户按序号选取商品,到场购物车

   购买,假诺商品总金额抢先总资金财产.则提示余额不足,不然购买成功

 

 

goods=[
{"name":"电脑","price":1999},
{"name":"鼠标","price":10},
{"name":"游艇","price":20},
{"name":"美女","price":998}
]
good_d={}
good_l=[]
tag=True
flag=True
while tag:
    allmoney=input("请输入总资产:").strip()
    if allmoney.isdigit():
        for good in  goods:
            print("{}.name:{name} price:{price}".format(goods.index(good) 1,name=good["name"],price=good["price"]))
            good_d[goods.index(good) 1]=[good["name"],good["price"]]

        while tag:
            number=int(input("请输入要购买商品的序号:").strip())
            if not number  or number not in good_d:
                print("输入错误。请重新输入:")
                continue
            else:
                flag=True
                while flag:
                    count=input("请输入要购买商品的件数:").strip()
                    if count.isdigit():
                        allprice=good_d[number][1]*int(count)
                        if allprice<=int(allmoney):
                            good_l.append((good_d[number][0],good_d[number][1],count))
                            allmoney=int(allmoney)- allprice
                            print("你的余额为",allmoney)
                            print(good_l)
                            break
                        else:
                            print("你的余额不足,请重新选择商品")
                            while True:
                                cmd=input("请输入命令,输入Y表示继续购物,输入N表示退出结账")
                                if cmd=="Y":
                                    flag=False
                                    break
                                elif cmd=="N":
                                    flag=False
                                    tag=False
                                    break

                                else:
                                    print("输入命令有误")
                                    continue


                    else:
                        print("输入有误。请重新输入:")
                        continue


    else:
        print("总金额必须是数字且不能为空!")

 

 

 

 

 

本文由澳门新萄京官方网站发布于www.8455.com,转载请注明出处:澳门新萄京官方网站:python3主干语法,学习笔记

关键词: