21python语法基础基础python语法，变量和数据类型

#####

python基础语法

1，关于注释：

单行注释：#，         多行注释：""""      """

2，严格区分大小写

比如打印print("123")   ----- 不能写成大写的Print("123")

3，严格的缩进

比如打印print("123")   ----- 前面不能有空格，有空格就不对，

#####

python的常量和变量

1，常量是不能被赋值的，变量可以被赋值

比如13 = 13 ，这是会报错的，因为13是一个常量，不能被赋值，

2，变量的赋值是使用的等于号，=

num = 13 ,这个就是变量赋值，

python变量定义的要求和规范

1，变量命名的要求

第一，标识符只能是字母数字下滑线组成，

第二，不能是数字开头，3num=13，这种就不行，

第三，标识符不能是关键字，

import keyword

print(keyword.kwlist) #可以查看有哪些关键字，

第四，标识符区分大小写，Num=14

2，变量命名的规范（标识符的命名规范）

标识符的通用要求

第一，就是见名知意，命名有一个有意义的名字，

第二，通用的命名方式有很多种：

类(class)的命名采用大驼峰命名法，首字母大写，如CamelCase；

函数的命名采用下划线分隔的小写字母，如separateed_by_underscores;

变量一般用小驼峰法标识。除第一个单词之外，其他单词首字母大写。myStudentCount;

####

python变量类型

# 一共是7种数据类型
# 1，Numbers（数字）
num = 10  # int整数
money=123.5  # 浮点数
data=1+2j  # 复数：用来描述平面上的一个坐标，x是1，y是2
# long1=0122L
# long 类型只存在于 Python2.X 版本中，在 2.2 以后的版本中，int 类型数据溢出后会自动转为long类型。在 Python3.X 版本中 long 类型被移除，使用 int 替代。
#############################
# 2，Boolean（布尔值）
isnum=True
# 3，String（字符串）
name='andy'
# 4，List（列表）
list1=[1,2,3]
# 5，set集合
set1= {'apple', 'orange', 'apple', 'pear', 'orange', 'banana'}
# 6，Tuple（元组）
tuple1=(1,2)
# 7，Dictionary（字典）
dict1={"name":"andy","age":18}

################################################

列举布尔值为False的常见值？
1，布尔型，False表示False，其他为True
2，整数和浮点数，0表示False，其他为True
3，字符串和类字符串类型（包括bytes和unicode），空字符串表示False，其他为True
4，序列类型（包括tuple，list，dict，set等），空表示False，非空表示True
5，None永远表示False

###############    字符串的基本操作    ###############

name ='andy'
print("my name is "+ name)  # 字符串连接
print(name*2)  # 重复输出字符串
print(name[1])  # 通过索引获取字符串中字符
print(name[0:2])  # 截取字符串中的一部分，遵循左闭右开原则
print('a' in name)  # 成员运算符 - 如果字符串中包含给定的字符返回 True
print('a' not in name)  # 成员运算符 - 如果字符串中不包含给定的字符返回 True
print('my name is %s,age is %d'%(name,18))  # 字符串格式化，%s是字符串，%d是整数

###############    字符串的常用内置函数    ###############

str1 = 'andy'
print(str1.capitalize())  # 将字符串的第一个字符转换为大写
print(str1.center(10,'*'))  # 这是把字符串在10个width中显示，空的显示后面的字符
print(str1.count('a',0,len(str1)))  # 方法用于统计字符串里某个字符出现的次数。可选参数为在字符串搜索的开始与结束位置。
print(str1.find('a',0,len(str1)))  # 检测字符串中是否包含子字符串 str ，如果指定范围,返回的是索引值在字符串中的起始位置。如果不包含索引值，返回-1。
print(str1.index('a',0,len(str1)))  # 跟find()方法一样，只不过如果str不在字符串中会报一个异常.所以一般还是用find
print(str1.isalnum())  # 如果字符串至少有一个字符并且所有字符都是字母或数字则返 回 True,否则返回 False
print(str1.isalpha())  # 如果字符串至少有一个字符并且所有字符都是字母则返回 True, 否则返回 False
print(str1.isdigit())  # 如果字符串只包含数字则返回 True 否则返回 False..
print(len(str1))  # 返回字符串长度
print(max(str1))  # 最大，
print(min(str1))  # 最小
print(str1.title())  # 返回"标题化"的字符串,就是说所有单词都是以大写开始，其余字母均为小写(见 istitle())
print(str1.upper())  # 转换字符串中的小写字母为大写
print(str1.replace("a","A",1))  # 字符串中的 old（旧字符串） 替换成 new(新字符串)后生成的新字符串，如果指定第三个参数max，则替换不超过 max 次。
print(str1.split('n',2))  # split() 通过指定分隔符对字符串进行切片，如果第二个参数 num 有指定值，则分割为 num+1 个子字符串。num -- 分割次数。默认为 -1, 即分隔所有。
seq=('a','d','d','y')
print('-'.join(seq))

例题：

# s = "ajldjlajfdljfddd"，去重并从小到大排序输出"adfjl"

s = "ajldjlajfdljfddd"
s = set(s)
print(s)  # {'l', 'f', 'd', 'j', 'a'}
s = list(s)
print(s)    # ['l', 'f', 'd', 'j', 'a']
# s= s.sort(reverse=False)  # sort没有返回值，所以这样写不对，
s.sort(reverse=False)
print(s)  # ['a', 'd', 'f', 'j', 'l']
s = "".join(s)
print(s)  # adfjl

例题

# x="abc",y="def",z=["d","e","f"],分别求出x.join(y)和x.join(z)返回的结果

x="abc"
y="def"
z=["d","e","f"]
print(x.join(y))  # dabc eabc f
print(x.join(z))  # dabc eabc f

# join()括号里面的是可迭代对象，x插入可迭代对象中间，形成字符串，结果一致，有没有突然感觉字符串的常见操作都不会玩了

 例题：

# a="hello"和b="你好"编码成bytes类型
a="hello"
b="你好"
a = b"hello"
b="你好".encode()
print(a,b)

 ###

字符串的转义和单引号，双引号，

a = ""

a1 = '"name":"value"'
a2 = "\"name\":\"value\""

print(a1)
print(a2)

这种细节的使用，要注意，

####

###############    列表的操作    ###############

list1=['my','name','is','andy']
# 访问列表：切片
print(list1[2])
print(list1[1:3])
print(list1[:-1])
# 更新列表
list1[0]='his'
print(list1)
list1.append('Lee')  # 这是在列表末尾插入元素
print(list1)
list1.insert(1,[1,2,3])  # 这是在指定位置插入元素
print(list1)
# 删除列表元素
del list1[4]
print(list1)
list1.remove(list1[3])
print(list1)
list1.pop()  # 移除列表中的一个元素（默认最后一个元素），并且返回该元素的值
print(list1)
# +和*，适用于字符串，同样适用于列表
print(list1+list1) # ['his', 'name', 'is', 'his', 'name', 'is']
print(list1*3) # ['his', 'name', 'is', 'his', 'name', 'is', 'his', 'name', 'is']

###############    列表的其他常用函数和方法    ###############

list1=['my','name','is','andy']
print(len(list1))
print(max(list1))
print(min(list1))
print(list1.count('my'))  # 统计某个元素在列表中出现的次数
print(list1.index('my'))  # 从列表中找出某个值第一个匹配项的索引位置
print(list1.reverse())  # 反向列表中元素
list2=[4,5,1,2,3]
list2.sort(reverse=True)  # reverse -- 排序规则，reverse = True 降序， reverse = False 升序（默认）。
print(list2)
list2.clear()
print(list2)
list3=list1.copy()
print(list3)

 python的append和extend有什么区别？

python的append和extend有什么区别？
答：extend()接受一个列表参数，把参数列表的元素添加到列表的尾部，append()接受一个对象参数，把对象添加到列表的尾部。

############################################

如何实现 “1,2,3” 变成 [‘1’,’2’,’3’] ?
list("1,2,3".split(','))

如何实现[‘1’,’2’,’3’]变成[1,2,3] ?
[int(x) for x in ['1','2','3']]

如何用一行代码生成[1,4,9,16,25,36,49,64,81,100] ?
i*i for i in range(1,11)]

一行代码实现删除列表中重复的值 ?
list(set([1, 2, 3, 4, 45, 1, 2, 343, 2, 2]))

#######################################

Python将两个列表/数组合并成一个列表/数组
extend方法
c1 = ["Red","Green","Blue"]
c2 = ["Orange","Yellow","Indigo"]
c1.extend(c2)
>>>c1 #["Red","Green","Blue","Orange","Yellow","Indigo"] 

直接相加
c1 = ["Red","Green","Blue"]
c2 = ["Orange","Yellow","Indigo"]
c3 = c1 + c2

 ###

列表转换成字符串，字符串转换成列表

list1 = [1,2,3,4]
list2 = ["1","2","3","4"]
list3 = ["1","2","3",4]

# print("".join(list1))  # 这种就不行，因为要求列表中的元素都是字符串，
# print("".join(list2))  # 这种就可以，
# print("".join(list3))  # 这种也不行，

###
# list1 怎么办？
# list1 = [str(i) for i in list1]  # 先通过列表推导式，把列表中的元素都转换成为字符串，
# print("".join(list1))  # 这样就可以了，

##########
# 字符串转换列表
str1 = "1234"
str2 = "1234abc一二三"
str3 = "1234,abc,一二三"

# print(list(str1))  # ['1', '2', '3', '4']
# print(list(str2))  # 所以所这种转换列表，是把字符串的每一个元素变为列表元素
# print(str2.split())  # 这种是split，就是一整个作为一个元素 ['1234abc一二三']
# print(str3.split(","))  # 这种是split，逗号分隔

####

###############    元组的操作    ###############

# 元组
# 创建空元组
tuple1=()
# 元组只包含一个元素时，需要在后面加逗号
tuple2=(1,)
print(type(tuple2))
# 访问元组
tuple3=(1,2,3)
print(tuple3[2])  # 所以一样可以使用切片的方式
# 修改元组
# 注意：元组里面的元素值是不能被修改的，但是可以进行连接，使用+
tuple4=tuple3+tuple2
print(tuple4)
# 也可以使用*号进行运算
print(tuple3*3)
# 也可以使用in来判断一个元素是否在这个元组内，返回True，和False，
print(3 in tuple3)
# 删除元组
# 元组里面的元素是不允许删除的，但是可以删除整个元组，
del tuple4
print(tuple4)
# 元组的内置函数
# 同样的元组内置函数也有len(),max(),min(),

################################################

字符串、列表、元组、字典每个常用的5个方法？
1，字符串  split/strip/replace/find/index ...
2，列表     append/extend/insert/push/pop/reverse/sort ...
3，元组     len/max/min/count/index ...
4，字典     keys/values/pop/clear/del ...
5，集合　 add/remove/clear/交集&、并集 |、差集 -　

python字典的使用-必须要彻底掌握！

###############    字典的操作    ###############

# 字典
dict1={"name":'andy',"age":18}
# 注意：字典的key必须是唯一的，值可以不是唯一的，
# 访问字典里的值
print(dict1['name'])
# 修改字典的值
dict1['age']=20
print(dict1)
# 往字典里面新增新的值
dict1['sex']='boy'
print(dict1)
# 所以也就是说如果有值就是修改，没有值就是新增，
# 删除字典的值
del dict1['sex']  # 删除某一个元素
dict1.clear()  # 清空字典的值
del dict1  # 删除整个字典，
# 字典的特性
# 字典的键必须不可变，所以可以是数字，字符串，元组，但是列表就不行，

###############    字典的内置函数    ###############

dict1={"name":'andy',"age":18}
# copy()
dict2=dict1.copy()  # 返回一个字典的浅复制
print(dict2)
# fromkeys()
seq=['name','age'] 
dict3=dict.fromkeys(seq,10) # 创建一个字典，以序列中的元素作为键，第二个参数是默认的值，不写默认是none print(dict3) # {'name': 10, 'age': 10}
# get()
print(dict1.get('name','NAN'))  # get() 函数返回指定键的值，如果值不在字典中返回默认值。
# print(dict1['name2'])  # 这种切片的方式会如果没有这个键会报错，所以一般是使用get的方式取值，不报错，
# dict1.keys()
dict1_key=dict1.keys()
print(dict1_key)  # dict_keys(['name', 'age'])
print(type(dict1_key))  # <class 'dict_keys'>
print(list(dict1_key))  # 可以转换为列表，
# dict1.items()
dict1_items=dict1.items()
print(dict1_items)  # 返回的是列表形式，里面的元素都是键值对构成的元组
# dict1.values()
dict1_values=dict1.values()
print(dict1_values)  # 返回一个迭代器，可以使用 list() 来转换为列表
# dict1.pop()
dict1_pop=dict1.pop('name2','默认值')  # 删除字典给定键 key 所对应的值，返回值为被删除的值。key值必须给出。 否则，返回default值
print(dict1_pop)

字典如何删除键和合并两个字典

dic = {"name":"andy","age":123}
del dic["name"]  # 删除键
# dic = {"age":123}

dic2  = {"name":"test"}
dic.update(dic2)  # 合并两个字典
# dic  = {"name":"test","age":123}

######