python学习笔记（一）Python基础

python学习笔记（一）Python基础

本次学习使用的是菜鸟教程

基础语法

1、标识符

标识符规则：

• 第一个字符必须是字母表中的字母或者下划线_
• 标识符的其他部分由字母、数字和下划线组成
• 标识符对大小写敏感

python的缩进规则

python使用缩进的空格数来表示代码块

if True:
  print("a")
else:
  print("b")

根据空格的数量来表示代码块

注释

单行注释

#12345

多行注释(三个单引号)

'''
12345
'''

多行注释2（三个双引号）

"""
12345
"""

数据类型

python只有四种数据类型

• int(整数)，如1，只有一种整数类型int，表示为长整型，没有python2中的long
• bool（布尔），True\False 首字母大写
• float(浮点数)，1.23，3E-2等
• complex（复数）如1+2j、1.1+2.2j

数据类型转换

格式：需要转换的数据类型(变量)

a=1.0
int(a)
print(a)

只能在数字类型之间转换

字符串

• python中的单引号和双引号是相同的

• 三个单引号或者三个双引号可以指定一个多行字符串

• 转义符号 \

• 反斜杠可以用来转移，使用r可以让反斜杠不发生转义，如：

  r"this is a line whth \n"
  

  这里会让\n显示，而不是换行

• 按字面意义级3联字符串，如"this" “is” “string"会自动转换成"this is string”.

• 字符串可以用+运算符连接，用*运算符重复

• python中的字符串有两种索引方式，从左到右以0开始，从右往左以-1开始。

• python中的字符串不能改变

• python中没有单独的字符类型，一个字符就是长度为1的字符串

• 字符串的截取语法格式如下：变量[头下表:尾下标：步长]

  字符串示例

  word='字符串'
  word2="字符串"
  word3="""
  字符串
  """"
  

# 截取字符串示例
str='123456'
#截取字符串是含头不含尾的
print(str)  #123456
print(str[0:1]) #1
print(str[1:3]) #23
print(str[1:4:2]) #24

列表

list语法

变量[头下标：尾下标]

索引以0为开始值，-1为末尾的开始位置

list=['a','b','c','d']
print(list)       #['a', 'b', 'c', 'd']
print(list[1:3])  #['b', 'c'] 表示从下标1到下标3之间的元素，不含尾
print(list[2:])   #['c', 'd'] 表示从下标2往后的所有元素
print(list*2)    #['a', 'b', 'c', 'd', 'a', 'b', 'c', 'd']
print(list+list)  #['a', 'b', 'c', 'd', 'a', 'b', 'c', 'd']

列表中的值可以直接改变，例如

a = ['a','b','c','d','e','f','g']
print(a[0])
a[0]=1
print(a[0])
print(a[1:3])
a[1:3]=['2','3']
print(a[1:3])
print(a)
a[1:3]=['1','2','3','4'] #给出的值与条件不符合的情况，会自动往后续
print(a[1:3])
print(a)

注意：

• List写在方括号之间，元素用逗号隔开
• 和字符串一样，list可以被索引和切片
• List可以使用+操作符进行拼接
• List中的元素是可以改变的

Python列表截取可以接收第三个参数，参数作用是截取的步长。

当第三个参数为负数的时候表示逆向读取，逆向的下标从-1开始

#列表元素翻转                                                                                                      
def reverseWords(input):                                                                                     
    inputWords=input.split(' ') #split()方法，以空格为界，将字符串转化为列表                                                   
    print(inputWords)                                                                                        
    inputWords=inputWords[-1::-1]     #第一个参数为-1，代表从最后一个开始，第二个参数不填代表顺次查到最后，第三个参数代表步长，-1表示逆向                   
    output=' '.join(inputWords)       #join()方法，将列表组合成新的字符串                                                  
    return output                                                                                            

if __name__ == '__main__':                                                                                   
    input ='Hello World'                                                                                     
    rw=reverseWords(input)                                                                        
    print(rw)                                                                                     

更新列表

用append()方法可以用来添加列表项

print('......................')
#append()方法添加列表项
c= ['a','b','c','d']
c.append('e')
print(c)

删除列表元素

用del语句删除列表元素（不是方法）

#用del语句删除列表元素
e=['a','b','c','d']
del e[0]  #删除列表e的0号元素
print(e)

列表脚本操作符

#Python列表脚本操作符
f=['a','b','c','d']
#len()计算列表长度
print(len(['a','b','c']))
print(len(f))
# +可以直接连接列表
print(f+e)
# *可以按顺序序，按次数复制填充列表
print(f*4)
# in 可以输出某元素是否在列表中
print('a' in f)
print(1 in f)
#for x in 列表 遍历
for x in f:print(x,end=' ') #end代表,用一个空格代表默认行末输出的换行符

列表的截取拼接

#列表嵌套
list2=[list1,f]
print(list2) #[[1, 2, 3, 1, 2, 3], ['a', 'b', 'c', 'd']]
print(list2[0]) #[1, 2, 3, 1, 2, 3]
print(list2[0][1])  #2

列表嵌套

#列表嵌套
list2=[list1,f]
print(list2) #[[1, 2, 3, 1, 2, 3], ['a', 'b', 'c', 'd']]
print(list2[0]) #[1, 2, 3, 1, 2, 3]
print(list2[0][1])  #2

List的相关函数

#列表函数相关方法的练习

list1=['a','b','c','d','e','f']
list2=[1,2,3,4,5]

#len(list)列表元素个数
print(len(list1)) #6

#max(list)返回列表元素最大值
print(max(list2)) #5

#min(list) 返回列表元素最小值
print(min(list2)) #1

#list(seq) 将元祖转换为列表
#元祖与列表类似，不同在于元祖的元素不能进行修改，元祖声明使用小括号，内元素用逗号隔开
#声明一个元祖，并转换为列表
seq=(1,2,3)
print(seq) #(1, 2, 3)
print(list(seq)) #[1, 2, 3]

#list.append(obj) 在列表末尾添加新对象
list1.append(1)
print(list1) #['a', 'b', 'c', 'd', 'e', 'f', 1]
list1.append(list2) #['a', 'b', 'c', 'd', 'e', 'f', 1, [1, 2, 3, 4, 5]]
print(list1)

#list.count(obj) 统计某个元素在列表中出现的次数
print(list1.count('a')) #1

#list.extend(seq) 在列表末尾一次性追加另一个序列中的多个值（用新列表拓展原来的列表）
list1.extend(list2)
print(list1) #['a', 'b', 'c', 'd', 'e', 'f', 1, [1, 2, 3, 4, 5], 1, 2, 3, 4, 5]

#list.index(obj) 在列表中找出某个值第一个匹配项的索引位置v
print(list1.index(1)) #6

#list.insert(index,obj) 将对象插入列表
list1.insert(7,2) #在第七个元素后面插入对象2 ['a', 'b', 'c', 'd', 'e', 'f', 1, 2, [1, 2, 3, 4, 5], 1, 2, 3, 4, 5]
print(list1)

#list.pop([index=-1]) 移除列表中的一个元素（默认最后一个元素），并返回该元素的值
print(list1.pop(8)) #[1, 2, 3, 4, 5]
print(list1)   #['a', 'b', 'c', 'd', 'e', 'f', 1, 2, 1, 2, 3, 4, 5]

#list.remove(obj) 移除列表中某个值的第一个匹配项
list1.remove('a')
print(list1) #['b', 'c', 'd', 'e', 'f', 1, 2, 1, 2, 3, 4, 5]

#list.reverse(）反向列表中的元素
list1.reverse()
print(list1) #[5, 4, 3, 2, 1, 2, 1, 'f', 'e', 'd', 'c', 'b']

#list.sort(key=None,reverse=False) 对原列表进行排序,key--可以在排序比较前指定一个函数，在排序前被调用，reverse--排序是否倒序
# list1.sort()
list3=[1,2,3,4]

print(list3)

list3.sort(reverse=True)
print(list3)
list3.sort(reverse=False)
print(list3)

#在排序之前 插入0
list3.sort(key=list3.insert(1,0))
print(list3)

#list.clear() 清空列表
list3.clear()
print(list3)

#list.copy()复制列表
list3=list2.copy()
print(list2)

#倒置字符串的再练习
if __name__ == '__main__':
    s="Hellow World"
    t=s.split(" ")
    t.reverse()
    tt=" ".join(t)
    print(tt)

元组

元组与列表是类似的，其元素位于小括号中，元素用逗号分隔开

不同之处是，元组中的元素不能修改

声明规则

#元组

tup1=('a','b','c')
tup2=(1,2,3)
tup3='a','b','c' #元组的声明可以不需要括号
print(tup3)

#元组中只包含一个元素时，需要在元素的后面加逗号，否则括号会作为运算符使用
tup4=('a')
print(type(tup4)) #str
tup5=('a',)
print(type(tup5)) #truple

访问元组

元组可以用下标索引来访问元组中的值,规则与列表是相同的

#下标访问元组
print(tup1[0]) #a
print(tup1[0:2]) #a,b
print(tup1[0:]) #a,b,c

修改元组

#修改元组,只能通过创建新元组的形式
tup6=tup1+tup2
print(tup6)
tup7=tup6+(1,)
print(tup7)

删除元组

#删除元组
del tup1 #将tup1在内存中被删除了

元组运算符

与列表的脚本操作符一致

元组的索引、截取

与列表的操作一致

元组的相关方法

len(tuple) #计算元组元素个数
max(tuple) #返回元组中元素最大值
min(tuple) #返回元组中元素最小值
tuple(iterable) #将可遍历的列表转化为元组

字典

字典是Python中一种可变容器模型，可以存储任意类型的对象

字典以键值对格式存在,以花括号声明,逗号分隔开

示例

d={key1:value1,key2:value2,key3:value3}

键值唯一，值可以不唯一

值可以取任意数据类型，但是键必须是不可变的，比如字符串和数字

访问字典里的值

在方括号中写入key值可以访问对应的value值

dict={1:'a',2:'b',3:'c'}

#访问字典里的值
print(dict[1])
print(dict[2])

修改字典

向字典添加新内容的方法是增加新的键值对，修改或删除已有键值对

直接对对应值进行赋值即可

#修改字典的值
dict[1]='b'
print(dict[1]) #b

删除字典元素

用del语句可以删除对应位置的键值对

#删除字典中的元素
del dict[1]
print(dict) #{2: 'b', 3: 'c'}

字典键的特性

• 一个键不能出现两次，如果对同一个键进行了两次的赋值，那么以后面的一个为准
• 键必须不可变，所以可以用数字，字符串或者元组充当，而列表就不行

字典中的内置方法

dict={
   'name':'jack',
    'job':'student',
    'salary':123
}
#字典内置的相关方法

#radiansdict.clear()删除字典内的所有元素(删除元素，并不是删除字典容器本身）
dict.clear()
print(dict)

dict={
   'name':'jack',
    'job':'student',
    'salary':123
}

#radiansdict.copy() 返回一个字典的浅复制(创建一个相同内容的字典容器)
print(dict.copy())

'''
radiansdict.fromkeys() 创建一个新字典，如果键不再字典中返回default设置的默认值
语法：dict.fromkeys(seq[,value])
seq --字典键值列表
value --可选参数，设置键序列(seq)对应的值，默认为None
'''

list=[1,2,3,4]
dict2=dict.fromkeys(list,10) #创建一个以list的值为键值，全部value为10的字典（不指定时的默认值为None)
print(dict2)

#radiansdict.get(key,default=None)返回指定键的值，如果键不在字典中返回default的默认值
print(dict.get('name'))
print(dict.get('a')) #键不在字典里就返回None

#key in dict 如果键在字典dict里就返回true，否则返回false
print('name' in dict) #True
print('a' in dict) #False

#radiansdict.items()以列表返回一个视图对象
print(dict.items())#即以一个键值对为一个元素，返回一个新的列表

#radiansdict.keys()
# radiansdict.values()
# 返回一个视图对象
print(dict.keys())#以每个键值为一个元素，返回一个新的列表
print(dict.values())#以每个value值为一个元素，返回一个新的列表

#radiansdict.setdefault(key,default=None) 和get()类似，
# 如果键不存在于字典中，将会添加键并将值设为deafult，区别就在于是否会创建新的键值
print(dict.setdefault('name1','123'))

#radiansdict.update(dict2) 将字典dict2的值/值对更新到dict里,相当于拼接
dict2={
   'name1':'jack',
    'job1':'student',
    'salary1':123
}

dict.update(dict2)
print(dict)


#dict.pop(key[.default])) 删除字典给定键key所对应的值，返回值为被删除的值。key值必须给出。否则，返回default值
print(dict.pop('name'))
print(dict)

#dict.popitem() 随机返回并删除字典中的最后一对键和值
print(dict.popitem())
print(dict)