学习笔记,python3主旨语法

  • 元组相加

    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指向一个新的地址

  • 变量

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

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

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

 

Python 3.6

 输出为

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()查看该变量的内存空间地址

6.声明变量注意事项有哪些?

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

2.变量名的第一个字符不能为数字

3.python关键字不能用作变量名

字符串

  • 字符串用单引号或双引号括起来。
  • 三引号(单引号或双引号均可)表示多行字符串,行末加反斜杠表示换行不算在字符串之内。
  • 字符串加上前缀 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'

  •  元组相乘

    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

8.如何查看变量在内存中的地址?

答:用id(变量名) 即可查看变量在内存中的地址

 

列表(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)]

 输出为

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

9.执行python程序时,自动生成的.pyc文件的作用是什么?

答:pyc是一种二进制文件,是由py文件经过编译后,生成的文件,是一种byte code,py文件变成pyc文件后,加载的速度有所提高,而且pyc是一种跨平台的字节码,是由python的虚拟机来执行的,py文件是可以直接看到源码的,所以就需要编译为pyc后,再发布出去,实现部分源码的隐藏.

元组(Tuples)

  • 元组:一种成员数量和次序固定但种类不尽相同的数据结构。
  • 元组采用小括号加逗号的特殊语法。(最外层元组的小括号可省略)
  • 元组是不可变的。
  • 元组存在下标语法。
  • 存在没有任何成员的元组 () 以及只有一个成员的元组 a, (元素后跟一个逗号表示元组)

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

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

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

10.写代码

解构语法

>>> a,b = [1,2]
>>> a,b
(1, 2)
>>> a,b = (1,2)
>>> a,b
(1, 2)
>>> a,b = b,a
>>> a,b
(2, 1)
  •  两个变量交换

    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)

  • 数值运算

a.实现用户输入用户名和密码,当用户名为seven且密码为123时,显示登陆成功,否则显示登陆失败.

 

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

 

 

集合(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'}

 

 

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

 

字典(Dictionaries)

  • 字典:一种存放键值对的哈希表数据结构。
  • 字典采用大括号加冒号和逗号的特殊语法。
  • 存在字典的解析表达式。(dictionary comprehensions)

    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}

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

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

 

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]

注意:

11.写代码

语句

  • 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
  1. python可以同时为多个变量赋值如 a , b = 1 , 2
  2. 一个变量可以通过赋值指向不同类型的对象
  3. 数值的除法(/)总是返回一个浮点数,要获取整数使用(//)操作符
  4. 在混合计算时,python会把整型转换为浮点型

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

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

 

函数

  • 定义函数使用 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]
  • 字符串(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.阅读代码,写出执行结果:

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的放在集合的第一个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.购物车

功能要求:

   要求用户输入总资产:如2000

   显示商品列表;用户按序号选择商品,加入购物车

   购买,如果商品总金额大于总资产.则提示余额不足,否则购买成功

 

 

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("总金额必须是数字且不能为空!")

 

 

 

 

 

本文由星彩网app下载发布于计算机编程,转载请注明出处:学习笔记,python3主旨语法

TAG标签:
Ctrl+D 将本页面保存为书签,全面了解最新资讯,方便快捷。