Python之路-变量和基本数据类型

一、注释

注释的作用：

　　增加程序的可读性

　　作为调试用

　　提高团队的合作效率

注释的分类

　　1、单行注释

　　以井号（#）开头，右边的所有内容当做说明

　　2、多行注释

　　以三对单引号（’’’注释内容’’’）将注释包含起来

其他语法

Python的语法比较简单，采用缩进的方式。

# print absolute value of an integer:
a = 100
if a >= 0:
	print(a)
else:
	print(-a)

　　上面代码中，以‘# ’是注释的标识符，可以记录当前代码所代表的意义，解释器会自动忽略这部分内容。 　　

　　当语句以‘：’结尾时，缩进语句视为代码块。 　　

　　在Python中，通常我们以4个空格的缩进来进行区分。可以在每句结束之后加一个‘;’号。通常在Python中，默认以换行为新的一行，若想在一行输入多句语句，一定要加‘;’，否则报错。

　　注意： 由于Python采用缩进的语法，在你复制，粘贴语句时，一定要注意，重新检查当前代码的缩进格式。 在Python中，对大小写十分敏感，如果大小写错误，会报错。

二、变量

标识符

　　什么是标识符
　　标识符是自己定义的,如变量名 、函数名等

标识符命名规则

　　1、只能包含字母、数字和下划线。变量名可以以字母或者下划线开头。但是不能以数字开头。

　　2、不能包含空格，但可以使用下划线来分隔其中的单词。

　　3、不能使用Python中的关键字作为变量名

　　4、建议使用驼峰命名法，驼峰式命名分为大驼峰（UserName）。和小驼峰（userName）。

常用关键字
　　系统有一些常用关键字不可以用来当做标识符。


and
lambda
except
while
del
return
import

or
class
try
if
assert
yield
as

in
def
finally
else
True
continue
from

is
global
raise
elif
False
pass

  

not
nonlocal
with
for
None
break

  

在Python中查看

import keyword
print(keyword.kwlist)

[‘False‘, ‘None‘, ‘True‘, ‘and‘, ‘as‘, ‘assert‘, ‘break‘, ‘class‘, ‘continue‘, ‘def‘, ‘del‘, ‘elif‘, ‘else‘, ‘except‘, ‘finally‘, ‘for‘, ‘from‘, ‘global‘, ‘if‘, ‘import‘, ‘in‘, ‘is‘, ‘lambda‘, ‘nonlocal‘, ‘not‘, ‘or‘, ‘pass‘, ‘raise‘, ‘return‘, ‘try‘, ‘while‘, ‘with‘, ‘yield‘]

三、数据类型

Number

　　int:

　　Python可以处理任意大小的整数，当然包括负整数，在程序中的表示方法和数学上的写法一模一样。

　　float:

　　浮点数也就是小数，之所以称为浮点数，是因为按照科学记数法表示时，一个浮点数的小数点位置是可变的。

　　complex:

　　一个实数和一个虚数的组合构成一个复数。

　　bool:

　　bool值是特殊的整型，取值范围只有两个值，也就是True和False。

 字符串

　　   字符串就是一系列任意文本。Python中的字符串用单引号或者双引号括起来，同时可以使用反斜杠（\）转义特殊字符。

　　单引号（’’）和双引号（"”）本身只是一种表示方式，不是字符串的一部分，因此，字符串’hello’只有h,e,l,l,o这五个字符。如果’本身也是字符的话，那么就可以用””括起来，比如”I’m OK” 当中包含了一个 ’ 。如果字符串内部包含 ’ 或者 ” ，但是又想当成普通字符串处理怎么办？这个时候就要用转义字符（\）来标识。

　　操作字符串

　　   截取字符串语法：变量[开始下标：结束下标]

　　加号（+）是字符串的连接符

　    星号（*）表示复制当前字符串

　　格式化Input输入

　　通过它能够完成从键盘获取数据，然后保存到指定的变量中 input获取的数据，都以字符串的方式进行保存，即使输入的是数字，那么也是以字符串方式保存

　　格式化输出

　　常用的格式符号:%[(name)][flags][width].[precision]typecode

　　字符串下标与切片

　　所谓”下标”就是编号,字符串实际是字符的组合。

　　声明一个字符串str1值为：abcd

切片是指对操作的对象截取其中一部分的操作。字符串、列表、元组都支持切片操作。

切片的语法：[起始:结束:步长]

字符串常用函数

练习：

# -*- coding:utf-8 -*-

‘‘‘
    格式化输出
‘‘‘

# name = ‘joe‘
# age = 18
# address = ‘上海‘
# print(‘大家好我叫%s，我今年%d岁，我来自%s‘%(name,age,address))
# print(‘大家好我叫%s‘%name)

‘‘‘
    字符串常用函数
‘‘‘
#find
# str = ‘I love python‘
# print(str.find(‘o‘))#返回的是该字符的位置
# print(str.find(‘w‘)) #没有的化返回-1

#index
# str = ‘I love python‘
# print(str.index‘o‘))#返回的是该字符的位置
# print(str.index(‘o‘)) #没有的化返回报错信息

#count
# str = ‘I love python‘
# print(str.count(‘o‘))#返回的是该字符出现的次数
# print(str.index(‘o‘,2,6)) #在指定位置查找出现的次数

#replace
# str = ‘I love python‘
# print(str.replace(‘p‘,‘P‘))#替换并输出  I love Python

#split
# str = ‘I love python o‘
# print(str.split(‘ ‘))#指定字符切分 [‘I‘, ‘love‘, ‘python‘, ‘o‘]

#capitalize
# str = ‘i love python o‘
# print(str.capitalize()) #将字符串的首字母大写I love python o

#capitalize
# str = ‘i love python o‘
# print(str.title()) #将字符串中每个单词的的首字母大写I Love Python O

#startswith
# str = ‘i love python o‘
# print(str.startswith(‘i‘)) #检测字符串是否以指定的字符开头 是则返回True 否则False

#swith
# str = ‘i love python o‘
# print(str.endswith(‘p‘)) #检测字符串是否以指定的字符结尾 是则返回True 否则False

#upper
# str = ‘i love python o‘
# print(str.upper()) #所有字母转化为大写

#lower
# str = ‘I LOVE PYTHON O‘
# print(str.lower()) #字符串转化为小写

#ljust
# str = ‘hello‘
# print(str.ljust(10)) #返回一个原字符串左对齐，并使用空格填充至长度width的新字符串hello

#rjust
# str = ‘hello‘
# print(str.rjust(10)) #返回一个原字符串右对齐，并使用空格填充至长度width的新字符串     hello

#center
# str = ‘hello‘
# print(str.center(10)) #返回一个原字符串居中，并使用空格填充至长度width的新字符串  hello

#lstrip
# str = ‘   hello‘
# print(str.lstrip()) #除去字符串左边的空白字符hello

#rstrip
# str = ‘hello   ‘
# print(str.rstrip()) #除去字符串右边的空白字符hello

#partition
# str = ‘hello world hello china‘
# print(str.partition(‘world‘)) #可以将字符串以str进行分割成三部分 str前，str,str后(‘hello ‘, ‘world‘, ‘ hello china‘)

#join
# str = ‘hello world hello china‘
# str1 = ‘-‘
# print(str1.join(str)) #str中每个字符后面插入str1,构造出新的字符串h-e-l-l-o- -w-o-r-l-d- -h-e-l-l-o- -c-h-i-n-a

#isspace
# str = ‘hello world hello china‘
# print(str.isspace()) #如果str中只包含空格，则返回true 否则返回false

#isalnum
# str = ‘hello‘
# print(str.isalnum()) #如果str中所有字符都是字母或者数字，则返回true 否则返回false

#isdigit
# str = ‘8765‘
# print(str.isdigit()) #如果str中只包含数字，则返回true 否则返回false

#isalpha
str = ‘hello china‘
print(str.isalpha()) #如果str中所有字符都是字母，则返回true 否则返回false

列表

列表写在[ ]内，元素之间用逗号隔开：

　　注意：

　　List写在方括号之间，元素用逗号隔开

　　和字符串一样，List可以被索引和切片

　　List可以使用加号（+）操作进行拼接

　　List中的元素是可以被改变的

列表的访问：

　　列表是由一系列按特定顺序排列的元素组成，列表能存储多种类型的数据，其中的元素之间可以没有任何关系

　　列表索引

列表的操作：

　　修改列表元素

　　修改列表元素的语法和访问列表元素的语法类似，指定列表名和要修改元素的索引，再指定新值

　　以下列表名为：students，需要将jack修改为tom

　　添加列表元素-1

　　在列表末尾追加元素：使用append()方法将元素追加到列表的末尾。也可以用append()方法来动态创建列表

　　以下列表名为：students，需要将‘篮球添加到列表的末尾’，使用append()方法

　　添加列表元素-2

　　在列表中插入元素：通过指定新元素的索引和值，使用insert()方法可以在列表的任何位置添加新元素

　　以下列表名为：students，需要将‘音乐插入到男的后面，使用insert()方法

　　删除列表元素

　　使用pop()方法删除元素：pop方法用于移出列表中的一个元素（默认是最后一个元素），可以指定元素索引，并且返回该元素的值。

　　使用del语句删除元素：如果知道要删除的元素在列表中的位置，可使用del语句删除元素，元素一旦被删除之后就再无法访问

　　使用remove()方法删除元素：当不知道元素索引，只知道元素值的时候，使用remove()方法删除元素

　　查找列表元素

　　所谓的查找，就是看看指定的元素是否存在

　　in（存在）,如果存在那么结果为true，否则为false

　　not in（不存在），如果不存在那么结果为true，否则false

　　Python列表函数

练习：

# -*- coding:utf-8 -*-

#列表：是由一系列特定顺序排列的元素组成
      # 列表可以存储多种类型的数据，
      # 元素之间没有任何关系

‘‘‘
    访问列表
‘‘‘

# list01 = [‘jack‘,‘jane‘,‘joe‘,‘black‘,‘‘]
# print(list01[2])  #通过下标访问

#二维列表
# list02 = [‘jack‘,‘jane‘,[‘leonado‘,‘joe‘],‘black‘,‘‘]
# print(list02[2])
# print(list02[2][0]) #获取leonado

# list02 = [‘jack‘,‘jane‘,[‘leonado‘,‘joe‘],‘black‘,‘‘]
# list02[0] = ‘lili‘   #通过下标获取到元素，并且给其赋新的值
# list02[2][0] = ‘susan‘
# print(list02)

#列表是一个可变的类型数据，允许我们对其里面的数据进行修改

‘‘‘
    列表的操作-追加
       append列表末尾追加
       insert指定位置插入
‘‘‘

#append
# list02 = [‘jack‘,‘jane‘,‘joe‘]
# list02.append(‘susam‘)
# print(list02)

#insert
# list02 = [‘jack‘,‘jane‘,‘joe‘,‘black‘]
# print(‘插入之前‘)
# print(list02)
# print(‘_‘*20)
# #指定位置插入
# list02.insert(1,‘susan‘)
# print(list02)

‘‘‘
    删除元素
       pop默认从最后删除,还可以通过指定索引删除
       del通过指定位置删除
       remove通过值删除
# ‘‘‘
# list02 = [‘jack‘,‘jane‘,‘joe‘,‘black‘]
# print(‘删除之前‘)
# print(list02)
# print(‘_‘*20)
# print(list02.pop())  #执行删除操作  并且返回删除的元素
# print(list02)
# print(‘继续删除‘)
# print(‘_‘*20)
# print(list02.pop(1))  #执行删除操作  并且返回删除的元素
# print(list02)
#del
# list02 = [‘jack‘,‘jane‘,‘joe‘,‘black‘]
# print(‘删除之前‘)
# print(list02)
# print(‘_‘*20)
# del list02[1] #指定索引删除  彻底删除
# del list02  #默认将整个列表 从内存中彻底删除，
# print(list02)

#remove 在不知道下标，但是知道具体值的时候通过值来删除
# list02 = [‘jack‘,‘jane‘,‘joe‘,‘black‘]
# print(‘删除之前‘)
# print(list02)
# print(‘_‘*20)
# list02.remove(‘jane‘) #通过元素的值进行删除
# print(list02)

‘‘‘
  查找元素是否存在
  in
  not in
‘‘‘
# list02 = [‘jack‘,‘jane‘,‘joe‘,‘black‘]
# name = ‘jack‘
# name2 = ‘lee‘
# print(name in list02)
# print(name2 in list02)

# list02 = [‘jack‘,‘jane‘,‘joe‘,‘black‘]
# name = ‘jack‘
# name2 = ‘lee‘
# print(name not in list02)
# print(name2 not in list02)
# -*- coding:utf-8 -*-

‘‘‘
    列表函数
‘‘‘

# list05 = [‘jack‘,‘jane‘,‘joe‘,‘black‘,‘12‘]
# #查看列表长度 返回列表元素个数
# print(len(list05)) #类似于一个方法，将参数传入

# list05 = [‘jack‘,‘jane‘,‘joe‘,‘black‘] #如果是字符类型，取字母靠后的
# list05 = [1,52,23,58,100] #默认数值输出结果，取最大值。
# print(max(list05)) #类似于一个方法，将参数传入

# list05 = [‘jack‘,‘jane‘,‘joe‘,‘black‘] #如果是字符类型，取字母靠迁的
# list05 = [1,52,23,58,100] #默认数值输出结果，取最小值。
# print(min(list05)) #类似于一个方法，将参数传入

# list05 = [‘jack‘,‘jane‘,‘joe‘,‘black‘,‘joe‘,‘jane‘]
# print(list05.count(‘joe‘)) #统计元素出现的次数

# list05 = [‘jack‘,‘jane‘,‘joe‘,‘black‘]
# list06 = [‘aaa‘,‘bc‘]
# list05.extend(list06) #扩展列表 在一个列表末尾一次性追加一个新列表 传入参数为一个列表 类似于单个元素使用append追加
# print(list05.extend(list06)) #必须先追加再输出
# print(list05)

# list05 = [‘jack‘, ‘jane‘, ‘joe‘, ‘black‘,‘joe‘]
# print(list05.index(‘joe‘)) #从一个列表中找出某一个值第一次出现的位置的索引

# list05 = [‘jack‘, ‘jane‘, ‘joe‘, ‘black‘,‘joe‘]
# list05.reverse() #对列表中的元素做反向旋转
# print(list05)
# print(list05.reverse()) #不可以在输出里面做旋转，必须先反向旋转再单独输出  和追加extend一样

# list06 = [2,3,5,9,6,12,40]
# list06.sort()  #对列表进行排序
# ‘print(list06.sort()) #先做排序  在输出
# print(list06)

# list05 = [‘jack‘, ‘jane‘, ‘joe‘, ‘black‘,‘joe‘]
# list05.clear() #用于清空列表
# print(list05)

# list05 = [‘jack‘, ‘jane‘, ‘joe‘, ‘black‘,‘joe‘]
# list07 = list05.copy() #复制列表
# print(list07)

#
# list = [‘lee‘,‘jone‘,‘jack‘]
# list.insert(0,‘teacher‘)
# list.insert(list.__len__(),‘bzr‘)
# print(list)
# # print(list.__len__())
# print(list[1][3])

元组

元祖写在小括号内，元素之间用逗号隔开

　　注意：

　　tuple的元素不可改变，但是可以包含可变的对象，比如list

　　构造包含0个或者1个元素的元祖有特殊语法规则：

　　tuple1=() #空元祖

　　tuple2=(1,) #一个元素，需要在元素后添加逗号

练习：

# -*- coding:utf-8 -*-

‘‘‘
    Python 里面的元祖和列表类似，不同之处在于元祖中的元素不能被修改，而列表中的元素可以被修改
    也可以进行分片和连接。元祖使用小括号，列表使用方括号。
‘‘‘

‘‘‘
    元祖 不可修改 提供了删除del 彻底删除（没法通过下标删除）
    元祖中的元素虽然不能被改变，但是元祖也是一个序列，也可以通过索引去访问和截取元祖指定位置的元素
    多维元祖：元祖中的元祖
‘‘‘
# tup01 = (1,2,3,4,5)
# print(tup01[3])

‘‘‘
    元祖函数：
‘‘‘

# tup01 = (1,2,3,4,5)
# print(len(tup01)) #计算元祖中元素的个数

# tup01 = (1,2,3,4,5)
# print(max(tup01)) #计算元祖中最大的元素

# tup01 = (1,2,3,4,5)
# print(min(tup01)) #计算元祖中最小的元素

# list = [‘jack‘,‘joe‘,‘black‘]
# print(type(list))
# print(tuple(list)) #将列表转化为元祖
# print(type(tuple(list)))

# tup01 = (1,2,3,4,5)
# print(list(tup01)) #将元祖转为列表  可以实现对元祖的修改

字典

字典是一种映射类型，使用{ }表示，他是一个无序的键（key）值（value）对集合

注意：

　　字典是一种映射类型，它的元素是键值对

　　键(key)必须使用不可变类型（字符串、数值、元组），在同一个字典中，键必须是唯一的。

　　创建空字典使用{ }

练习：

# -*- coding:utf-8 -*-

‘‘‘
    字典是用户自己创建索引 通过前面的下标操作
‘‘‘
# dict = {‘name‘:‘job‘,‘age‘:18,‘address‘:‘上海‘}
# print(dict)
#访问
# print(dict[‘name‘])

#修改
# dict = {‘name‘:‘job‘,‘age‘:18,‘address‘:‘上海‘}
# dict[‘name‘] = ‘jack‘
# print(dict)

#添加元素
# dict = {‘name‘:‘job‘,‘age‘:18,‘address‘:‘上海‘}
# dict[‘hobby‘] = ‘足球‘
# print(dict)#多次运行发现输出的顺序不一样，不一定在最后

#删除
# dict = {‘name‘:‘job‘,‘age‘:18,‘address‘:‘上海‘}
# del dict[‘address‘] #删除某一个
# del dict #整个字典彻底从内存删除 表名都不存在了
# print(dict)

# dict = {‘name‘:‘job‘,‘age‘:18,‘address‘:‘上海‘}
# dict.clear()
# print(dict) #{}  清空所有元素

‘‘‘
    字典函数
‘‘‘
# dict = {‘name‘:‘job‘,‘age‘:18,‘address‘:‘上海‘}
# print(len(dict)) #计算字典中元素的个数

# dict = {‘name‘:‘job‘,‘age‘:18,‘address‘:‘上海‘}
# print((str(dict)) #输出字典，以可打印的字符串表示。转为str类型
# print(type(str(dict)))

#dict.fromkeys(seq[,]value)
#创建一个新的字典，以seq中的元素作为字典的前半部分的key值,value为字典所有键对应的默认初始化的值
# seq = (‘name‘,‘age‘,‘sex‘)
# dict01 = dict.fromkeys(seq)
# print(‘新字典为：‘,dict01)
# dict02 = dict.fromkeys(seq,‘jack‘) #对vlue赋值
# print(‘新字典为：‘,dict02)

#dict.get(key,default=None)
#返回指定键的值   如果不在字典里面返回default值
# dict = {‘name‘:‘job‘,‘age‘:18,‘address‘:‘上海‘}
# print(‘age键的值为：‘,dict.get(‘age‘))
# print(‘sex键的值为：‘,dict.get(‘sex‘)) #没有返回默认none
# print(‘sex键的值为：‘,dict.get(‘sex‘,‘男‘)) #字典里面没有可以手动指定
# print(‘ddress键的值为：‘,dict.get(‘ddress‘,‘北京‘))#如果建值字典里面有，但是自己手动指定则已手动指定的输出

#key in dict
#如果键在字典dict里面返回true,否则返回false
# dict = {‘name‘:[‘job‘,‘tom‘],‘age‘:18,‘address‘:‘上海‘}
# if ‘age‘ in dict:
#     print(‘键age在字典里面存在‘)
# else:
#     print(‘键age不在字典里面存在‘)

# dict.keys()
# 以列表形式返回字典里面所有的键 值
# dict = {‘name‘:[‘job‘,‘tom‘],‘age‘:18,‘address‘:‘上海‘}
# print(dict.keys()) #dict_keys([‘age‘, ‘address‘, ‘name‘])
# print(dict.values()) #dict_values([18, [‘job‘, ‘tom‘], ‘上海‘])

# dict = {‘name‘:[‘job‘,‘tom‘],‘age‘:18,‘address‘:‘上海‘}
#以键值对形式保存在列表中
# print(dict.items()) #dict_items([(‘address‘, ‘上海‘), (‘age‘, 18), (‘name‘, [‘job‘, ‘tom‘])])

四、运算符

　　算术运算符

　　赋值运算符

　　比较运算符

　　逻辑运算符

　　位运算符

算术运算符

以下假设变量a=10，变量b=20

赋值运算符

 比较运算符

以下假设变量a=10，变量b=20

逻辑运算符

位运算符

a = 60 b = 13

练习：

# -*- coding:utf-8 -*-

‘‘‘
    int
‘‘‘

# a = 1
# print(type(a)) #type是python里面用来查看数据类型的函数

‘‘‘
    boolean
    True 不为零 False 为零
‘‘‘
# a = True
# print(type(a))

‘‘‘
    字符串 string
    一般使用单引号 或者双引号
‘‘‘
# a = ‘刘德华‘
# name= "黎明"
# num = ‘1‘
# num2 = ‘True‘ #带上引号的都是字符串
# print(type(a))
# print(type(name))
# print(type(num))

# str1 = ‘"ni hao"‘ #双引号成了字符串本身
# print(str1)

# str2 = "‘你 好‘" #单引号成了字符串本身
# print(str2)

# str3 = ‘aaa\‘bbb‘ #最外面的单引号是一对 里面的单引号通过\转义
# print(str3)

#字符串截取
# str = ‘abcdefg‘
# print(str)
# print(str[1:5]) #含头不含尾
# print(str[-1])  #输出g 从最后开始输出
# print(str[2:])  #默认输出到最后
# print(str[:2])
# print(str[1:5:2]) #截取1到5 2是步长 隔一个拿取第二个
# print(str[1:5:1]) #等价于print(str[1:5]) 一个一个拿取
# print(str[::-1])  #反向输出
# print(str[5:2:-1])

#运算符
#+
# num1 = 10
# num2 = 3
# print(num1 + num2)
# print(num1 - num2)
# print(num1 * num2)
# print(num1 / num2)
# print(num1 % num2)
# print(num1 // num2) #返回商的整数部分，
# print(num1 ** num2) #幂 num1的num2次幂

‘‘‘
    赋值运算
‘‘‘
# str = ‘a‘

# num = 1
# num += 1 #num = num + 1 先加
# print(num)

# num = 10
# num -= 1 #num = num - 1 先减
# num *= 2 #num = num * 2
# num /= 2   #num = num / 2
# num %= 2 #num = num % 2
# num **= 2 #num = num ** 2
# num //= 2 #num = num // 2
# print(num)

‘‘‘
    比较运算
‘‘‘
# a = 10
# b = 5
# print(a == b)
# print(a != b)
# print(a > b)
# print(a < b)
# print(a >= b)
# print(a <= b)

‘‘‘
    逻辑运算
‘‘‘
#and
# a = 10
# b = 5
# print(a > b and a < b) #两个条件为真，则为真，否则为假
# print(a > b or a < b) #两个条件有一个为真，则为真
# print(not a > b) #非

# str = ‘‘ #空的字符串返回 bool False
# str = [] #空的列表返回 bool False
# str = () #空的元组返回 bool False
# str = {} #空的字典返回 bool False
# str = 0 #0 返回 bool False
# print(bool(str))

‘‘‘
    位运算
‘‘‘
a = 4
b = 2
‘‘‘
十进制：1，2,3,4,5,6,7,8,9,10,11
二进制：0000，0001,0010,0011,0100
    0000 0100 表示4
    0000 0010    2
 $  0000 0000    0 #对应位同时为1则为1 否则为0
 |  0000 0110    6
‘‘‘
#按位与运算符 &
#参与运算的两个值，如果两个相应位都为1，则该位的结果为1，否则为0
# print(a & b ) #0

#按位或运算符 |
#参与运算的两个值，只要对应的两个二进制有一个为1，则该位的结果为1
# print(a | b)  #6

#按位异或运算符 ~
#参与运算的两个值，当对应的两个二进制相异时，则该位的结果为1
# print(a ^ b)

#按位取反运算符~
#对数据的每个二进制取反，即把1变为0，把0变为1
# print( ~ a ) # -4-1  -5 (取负数 再减1)

#左移运算符 <<
#运算数的各二进位全部左移若干位，由"<<"右边的数字决定移动的位数
#高位丢弃，低位补0

#右移运算符 >>
#把“ >>”左边的运算数的各二进位全部右移若干位，由">>"右边的数字决定移动的位数

　　

原文地址：https://www.cnblogs.com/lyywj170403/p/10301343.html

时间： 2024-10-29 05:35:53

Python之路-变量和基本数据类型的相关文章

python学习笔记——变量和简单数据类型

1.变量的命名 同C语言 2.字符串 就是一系列字符. 在Python中, 用引号括起的都是字符串, 其中的引号可以是单引号, 也可以是双引号 2.1使用方法修改字符串的大小写 对于字符串, 可执行的最简单的操作之一是修改其中的单词的大小写. 请看下面的代码, 并尝试判断其作用     (就是调用一个类似函数的语句,格式为变量名称后面加个点,再加上方法的名称) name = "ada lovelace" print(name.title()) 上段代码的意思就是利用title()这个方

python之路-变量

变量 1.1变量的命名规则 1.可包含字母,数字和下划线,变量名不能以数字打头. 2.大小写敏感,表示的是不同的变量. 3.以下划线打头的变量具有特殊的含义,一般不建议使用. 4.关键字和保留字不能作为变量名. 推荐 1.驼峰命名法之大驼峰 每个单词第一个字母均大写,在Python中给类命名使用此法 2.驼峰命名法之小驼峰 类似大驼峰,但第一个字母小写,在Python中一般给普通变量或者函数命名 3. posix写法 多个单词用下划线链接,单词全部小写 1.2变量类型 1.数字 #整数##二进制

python之路 --变量声明和变量名命名规则

1.声明(定义)变量: username='alex'上面声明了一个变量,变量名为:username, 变量值为:alex 2.变量名必须是字母,数字和下划线的任意组合:必须以下划线或英文字母开始, 不能是数字开头. username='alex'          ---正确的格式   _username2="xiaomi" ----正确的格式   3username='xiaohua' ----错误的格式

Python基础-2 变量与常量

变量与常量 变量:在程序运行过程中,值会发生变化的量 常量:在程序运行过程中,值不会发生变化的量 无论是变量还是常量,在创建时都会在内存中开辟一块空间,用于保存它的值. 这里有一点需要注意的是,在python中是不需要声明类型的.这是根据Python的动态语言特性而来.变量可以直接使用,而不需要提前声明类型. 变量的定义 Python 中的变量不需要声明类型 a = 4 b = "hello" c = [1,2] d = (1,2) 这些变量都是不需要声明它的类型的,在C和Java中是

Python之路番外：PYTHON基本数据类型和小知识点

Python之路番外:PYTHON基本数据类型和小知识点 一.基础小知识点 1.如果一行代码过长,可以用续行符 \换行书写 例子 if (signal == "red") and (car == "moving"): car = "stop" else : pass 等同于 if (signal == "red") and (car == "moving"): car = "stop"

python中的变量和数据类型

一.变量定义:变量是计算机内存中的一块区域,存储规定范围内的值,值 可以改变,通俗的说变量就是给数据起个名字. 二.变量命名规则: 1. 变量名由字母.数字.下划线组成 2. 数字不能开头 3. 不可以使用关键字, 举例:a,a1,a_1 三.变量的赋值: 1. Python中的变量不需要声明,变量的赋值就是变量声明和 定义的过程: 2. 每个变量在使用前都必须赋值,变量赋值以后该变量才会 被创建: 3. 等号(=)用来给变量赋值,等号(=)运算符左边是一个 变量名,等号(=)运算符右边是存储在

Python小白学习之路—变量、字符编码、字符拼接

变量命名规则: (1)变量名只能是字母,数字,下划线的任意组合. ex:_amber_666NAme (2)关键字不能声明为变量名 ex:['and', 'as', 'assert', 'break', 'class', 'continue', 'def', 'del', 'elif', 'else', 'except', 'exec', 'finally', 'for', 'from', 'global', 'if', 'import', 'in', 'is', 'lambda', 'not'

Python学习笔记---变量与数据类型

Python中的变量与内置数据类型 本文只是我在慕课网学习<Python入门>这门课程时,摘录.整理的一些对自己比较重要的语法与提示.九成以上的内容以及所有代码示例,均摘抄自慕课网.由于我本人有一定C/C++语言基础,而本文主要供我自己复习使用,所以我偏向于摘录一些Python和C/C++之间的差异之处,可能造成本文语义上不一定连贯,建议有学习需求的读者直接前往慕课网学习该课程(链接:http://www.imooc.com/learn/177)或是查看该门课程授课教师廖雪峰先生官方网站所给出

小白的Python之路 day1 变量

Python之路,Day1 - Python基础1 变量 变量用于存储在计算机程序中引用和操作的信息.它们还提供了一种用描述性名称标记数据的方法,这样我们的程序就能更清晰地被读者和我们自己理解.将变量看作保存信息的容器是很有帮助的.它们的唯一目的是在内存中标记和存储数据.然后可以在整个程序中使用这些数据. 声明变量 1 2 3 #_*_coding:utf-8_*_ name = "Many Qian" 上述代码声明了一个变量,变量名为: name,变量name的值为:"Ma