python代码大全和用法,python入门基础代码

本篇文章给大家谈谈python代码大全和用法，以及python入门基础代码，希望对各位有所帮助，不要忘了收藏本站喔。

Source code download: 本文相关源码

这篇文章主要介绍了python代码大全和用法，具有一定借鉴价值，需要的朋友可以参考下。希望大家阅读完这篇文章后大有收获，下面让小编带着大家一起了解一下python基础知识重点。

1、标识符和保留字

查看保留字：

import keyword
print(keyword.kwlist)

• 标识符：以字母、数字、下划线组成
• 数字不能开头
• 不能以保留字命名
• 严格区分大小写

2、变量（值可以被改变）

• 一个变量包括三部分：id、type、value
• 它的类型type完全由等号右边的值的类型决定
• 当对一个变量多次赋值以后，这个变量名会指向新的存储空间
• 变量的命名遵循驼峰式命名法

• name='小白'
  print('类型',type（name）)
  print('地址',id(name))
  print('值',name)

  扫描二维码关注公众号，回复： 17427540 查看本文章

3、常见的数据类型

1. 整数类型->int->123
2. 浮点数类型->float->3.1415926
3. 布尔类型->bool->True、False
4. 字符串类型 ->str->"Python  ,I love you "

• 布尔值可以转换为整数：True=1   False=0

• print(True+1)#2
  print(False+1)#1

 4、数据类型转换————三个函数

1. str()——将其他数据类型转成字符串类型
2. int()——将其他数据类型转成整数类型
3. float()——将其他数据类型转成浮点数型

name='张三'
age=18
#这样写print('我叫'+name+'年龄'+age)会报错，因为在python中，str类型和int类型不能直接拼接,必须先将int类型转换为str类型，才可以
print('我叫'+name+'年龄'+(str)age)#将age进行一个类型转换，转换为str类型

5、input（）函数的使用

• 作用：接受用户从键盘输入的数据
• 返回值类型：字符串类型str
• 值的存储：使用=对输入的值进行存储

• a=input('请您输入第一个整数')#10
  b=input('请您输入第二个整数')#30
  print(a+b)#结果为1030，可见只起到了字符串拼接的作用
  
  a=int(input('请您输入第一个整数'))
  b=int(input('请您输入第二个整数'))
  print(a+b)#结果为40，类型转换以后可以进行相加

6、运算符

1. 算术运算符：+、-、*、/(取商，即除法运算)、//（整除，只保留商的整数部分）、%（取余运算）、a**b(表示a的b次方)
2. 赋值运算符：=
3. 比较运算符：>=、<=、==、+=、-=等
4. 布尔运算符：and 、or、 not、   in、    not  in
5. 位运算符：将数据转为二进制进行运算

 整除特例：

print(9//4)#2
print(-9//-4)#2

#整除时，一正一负向下取整
print(-9//4)#-3
print(9//-4)#-3

取余特例（一正一负要遵循公式）： 余数=被除数-除数*商

print(9%4)#1

#一正一负时，公式为：余数=被除数-除数*商
print(-9%4)#-9-4*（-3）=3
print(9%-4)#-3=9-（-4）*（-3）

7、程序的组织结构

1. 顺序结构
2. 选择结构
3. 循环结构

 单分支结构：

if 条件表达式：

        条件执行体

双分支结构：

if 条件表达式：

        条件执行体1

else:

        条件执行体2 

多分支结构：

if 条件表达式：

        条件执行体1

elif:

        条件执行体2 

elif:

        条件执行体3

else:

        条件执行体n

分支结构——嵌套if的使用

if 条件表达式：

        if 内层条件表达式：

                内层条件执行体1

        else  ：

                内层条件执行体2

else:

        条件执行体

while循环结构

while 条件表达式：

        条件执行体（循环体）

 for- in循环

1. in表示从字符串、序列、字典、元组等中依次取值，又称为遍历
2. for-in遍历的对象必须是可迭代对象
3. 语法结构
4. for    自定义的变量  in   可迭代对象：
   1.         循环体  

• 对象的布尔值：python中一切皆对象，每一个对象都有自己对应的bool值，可以用内置函数bool()来查看

8、内置函数range()的应用 

1. 创建range()对象的三种方式

• range（stop）

• a=range(10)  #[0,1,2,3,4,5,6,7,8,9],默认从0开始，步长是1
  print(a) #range(0,10)
  print(list(a))#查看range对象中的整数序列

• range(start,stop)

• a=range(1,10) #[1,2,3,4,5,6,7,8,9]从1开始，到10但是不包括10
  print(list(a))#查看迭代器中的整数序列

• range(start,stop,step)

• a=range(1,10,2)#[1,3,5,7,9]从1开始，到10结束，步长为2
  print(list(a))#将迭代器中的整数序列打印出来

9、流程控制语句

1. break:用于结束 循环结构，通常与if分支语句一起使用
2. continue：用于结束当前循环，进入下一次循环

for …… in ……：

        ……

        if  ……：

                break 

 while   条件：

        ……

        if  ……：

                break

10、列表（相当于java\C\JavaScript中的数组） ——索引也是从0开始的

1. 列表的创建方式

• 使用内置函数list()
• 使用中括号

• #列表的第一种创建方式[]
  a=['pink','green','yellow','blank']
  
  #列表的第二种创建方式内置函数list()
  b=list(['pink','green','yellow','blank'])

2、列表的特点

1. 列表元素类型混存
2. 根据需要动态分配和回收内存
3. 列表可以存储重复数据 
4. 索引映射唯一一个数据

3、列表的查询操作

•  获取列表中指定元素的索引（当列表中这个元素出现多次时，只返回第一个元素的索引）

a=list(['hello','world','hello',98,'hi'])
print(a.index('hello'))#结果为0
print(a.indexx('hello',1,3))#结果为2    在列表的1-3的位置上去查找hello(从1这个位置开始，到3而不包括3)

• 获取列表中的单个元素 

a=['hello',1,2,3,'world']#创建列表

#获取索引为3的元素
print(a[3])#3

#获取索引为-3的元素
print(a[-3])#2

• 获取列表中的多个元素，切片操作 

语法格式：[start:stop:step] 

a=[10,20,30,40,50,60,70,80,90]
print(a[1:6:1])#结果为[20, 30, 40, 50, 60]
print('原列表',id(a))#原列表 2692295109632
b=a[1:6:1]
print('切的片段id',id(b))#切的片段id 2692295430592
c=a[1:6:2]
print(c)#结果为[20, 40, 60]

• 列表元素的判断和遍历 

元素  in  列表名   #返回值是布尔类型

元素  not in 列表名

for 迭代变量  in  列表名：

                操作 

a=[10,20,30,40,50,60,70,80,90]
for item in  a:
    print(item,end=" ")   #10 20 30 40 50 60 70 80 90 

• 列表元素的添加、删除、修改、排序操作 

插入操作： 

list=[10,20,30,40,50,60]
print('添加元素前',list)#添加元素前 [10, 20, 30, 40, 50, 60]
print(id(list))#1520019188800

#向列表的末尾添加一个元素
list.append(100)
print('添加元素后',list)#添加元素后 [10, 20, 30, 40, 50, 60, 100]
print(id(list))#1520019188800

#向列表的末尾至少添加一个元素
list2=['hello','world']
list.extend(list2)
print(list)#[10, 20, 30, 40, 50, 60, 100, 'hello', 'world']

#向任意一个位置插入一个元素
list.insert(1,90)
print(list)#[10, 90, 20, 30, 40, 50, 60, 100, 'hello', 'world']

#在任意的位置上添加至少一个元素
list[1:]=list2
print(list)#[10, 'hello', 'world']

删除操作：

list=[10,30,20,20,30]
list.remove(30)#[10, 20, 20, 30]删除指定元素，如果有多个，只删除第一个
print(list)

#根据索引删除元素
list.pop(0)
print(list)#[20, 20, 30]
list.pop()#如果不指定索引，将默认删除列表中的最后一个元素
print(list)#[20, 20]

#切片操作，删除至少一个元素，将产生一个新的对象
print("-------------------------------")
list2=[10,30,20,20,30]
newList=list2[1:3]
print(list2)#[10, 30, 20, 20, 30]
print(newList)#[30, 20]

#不产生新的对象，而是删除原列表中的元素
print('-------------------------------')
list3=[10,30,20,20,30]
list3[1:3]=[]
print(list3)#[10, 20, 30]

#清除列表中的所有元素
print('=---------------------')
list4=[10,30,20,20,30]
list4.clear()
print(list4)#[]

修改操作：

list=[10,30,20,20,30]
list[2]=100
print(list)#[10, 30, 100, 20, 30]

#修改一段列表片段的元素
list[1:3]=['hello','world']
print(list)#[10, 'hello', 'world', 20, 30]

排序操作：

list=[13,1,56,23,78,9]
print('排序前',list)#排序前 [13, 1, 56, 23, 78, 9]
list.sort()
print('排序后',list)#排序后 [1, 9, 13, 23, 56, 78]

#通过指定关键字参数，对列表进行降序排序
print('----------------------------')
list2=[13,1,56,23,78,9]
list2.sort(reverse=True)#reverse=True表示降序排序   reverse=False表示升序排序
print(list2)#[78, 56, 23, 13, 9, 1]

list3=[13,1,56,23,78,9]
list3.sort(reverse=False)#reverse=False表示升序排序
print(list3)#[1, 9, 13, 23, 56, 78]


print('------------使用内置函数sortd()对列表进行排序-------------------')
list4=[55,23,2,4,1,78,0]
newList=sorted(list4)
print(list4)#[55, 23, 2, 4, 1, 78, 0]
print(newList)#[0, 1, 2, 4, 23, 55, 78]

#指定关键字参数，实现列表元素的降序排序
print('------------降序排序')
list5=[55,23,2,4,1,78,0]
descList=sorted(list5,reverse=True)
list6=sorted(list5,reverse=False)
print(list5)
print(descList)#[78, 55, 23, 4, 2, 1, 0]
print(list6)#[0, 1, 2, 4, 23, 55, 78]

列表生成式：

i*i           for         i         in         range   (1,10) 

注意事项：表示列表元素的表达式中，通常包含自定义变量

list=[i for i in range(1,10)]
print(list)#[1, 2, 3, 4, 5, 6, 7, 8, 9]

list=[i*i for i in range(1,10)]
print(list)#[1, 4, 9, 16, 25, 36, 49, 64, 81]

11、字典

1. 与列表一样是一个可变序列
2. 以键值对的方式存储，是一个无序的序列
3. 即你第一个放进来的并不一定就在第一个位置上，第二个放进来也不一定在第二个位置上
4. 键不可以重复，值可以重复，当键重复时，会发生值覆盖的情况  

• 字典的创建   

1. 使用花括号
2. 使用内置函数dict() 

#第一种
score={'张三':18,'李四':19}
print(score)#{'张三': 18, '李四': 19}
print(type(score))#<class 'dict'>
#第二种
student=dict(name='jack',age=11)
print(student)#{'name': 'jack', 'age': 11}
#创建空字典
dic={}
print(dic)

• 增加 

score={'张三':18,'李四':19}
print(score['张三'])#18
print(score.get('张三'))#18
print(score.get('王五',98))#是指当我们的键不存在时，对应的默认值

• 删除 和修改

score={'张三':18,'李四':19}
print('张三' in score)#True
print('张三' not in score)#False

del score['张三']#删除指定的key-value对
#score.clear()
print(score)#{'李四': 19}

#增加
score['jack']=12
print(score)#{'李四': 19, 'jack': 12}

#修改
score['jack']=100
print(score)#{'李四': 19, 'jack': 100}

• 获取字典试图的三个方法 

1、获取字典的键key()

2、获取字典的值value()

3、获取字典的键值对items() 

score={'张三':18,'李四':19}
key=score.keys()
value=score.values()
items=score.items()
print(key)#dict_keys(['张三', '李四'])
#将所有的键所获得的值转为列表
print(list(key))#['张三', '李四']
print(value)#dict_values([18, 19])
print(list(value))
print(items)#dict_items([('张三', 18), ('李四', 19)])
#之后的列表元素是由元组组成的
print(list(items))

• 字典元素的遍历 

score={'张三':18,'李四':19}
for i in score:
    print(i,end=' ')#张三 李四 将所有的键遍历出来并打印
    #根据键获取值
    print(score[i])
    print(score.get(i))

• 字典生成式 

key=['banana','orange','apple']
price=[12,13,14]
s={key:price  for key,price  in zip(key,price)}
print(s)
#{'banana': 12, 'orange': 13, 'apple': 14}

写到这里投入了很多精力和时间，一看字数，感觉篇幅太长了，所以这篇就先写到这里吧，剩下的从元组开始会写到Python基础语法知识（二）里面，看别人写，跟自己写一遍真的会有不同的感觉，所以建议跟我一样初学Python的人也可以跟我一样自己写一遍，我觉得这个内容已经是基础中的基础了，适合想要自学Python的小伙伴入门来看，道阻且长，行则将至。代码的世界看似变化多端，实则还是有迹可循的，一起加油吧！