基本数据类型-列表_元组_字典_day4
一、列表（list)
书写格式：[]
#通过list类创建的 li = [1, 12, 9, "age", ["刘正文", ["", 10, ],"庞麦郎"], "ales", True]
1、列表格式
2、列表中可以嵌套任何类型
- 中括号起来
- ，分割每个元素
- 列表中的元素可以是 数字，字符串，列表，布尔值....所有的都能放进去
- "集合" ，内部放置任何东西
3、索引取值
li = [1, 12, 9, "age", ["刘正文", ["", 10, ],"庞麦郎"], "ales", True]
print(li[3]) #索引取值
执行结果：
age
4、切片，切片结果也是列表
li = [1, 12, 9, "age", ["刘正文", ["", 10, ],"庞麦郎"], "ales", True]
print(li[3:-1]) #切片，切片的结果也是列表
执行结果：
['age', ['刘正文', ['', 10], '庞麦郎'], 'ales']
5、for循环
while循环
li = [1, 12, 9, "age", ["刘正文", ["", 10, ],"庞麦郎"], "ales", True]
for item in li:
print(item)
执行结果：
1
12
9
age
['刘正文', ['', 10], '庞麦郎']
ales
True
6、索引
- 修改
列表元素，可以被修改
ps1:
li = [1, 12, 9, "age", ["刘正文", ["", 10, ],"庞麦郎"], "ales", True]
li[1] = 120
print(li)
执行结果：
[1, 120, 9, 'age', ['刘正文', ['', 10], '庞麦郎'], 'ales', True]
ps2:
li = [1, 12, 9, "age", ["刘正文", ["", 10, ],"庞麦郎"], "ales", True]
li[1] = [11,22,33,44]
print(li)
执行结果：
[1, [11, 22, 33, 44], 9, 'age', ['刘正文', ['', 10], '庞麦郎'], 'ales', True]
- 删除
删除，第一种方式
li = [1, 12, 9, "age", ["刘正文", ["", 10, ],"庞麦郎"], "ales", True]
del li[1] #删除12
print(li)
执行结果：
[1, 9, 'age', ['刘正文', ['', 10], '庞麦郎'], 'ales', True]
7、切片
- 修改
li = [1, 12, 9, "age", ["刘正文", ["", 10, ],"庞麦郎"], "ales", True]
li[1:3] = [120,90] #修改12,9
print(li)
执行结果：
[1, 120, 90, 'age', ['刘正文', ['', 10], '庞麦郎'], 'ales', True]
- 删除
li = [1, 12, 9, "age", ["刘正文", ["", 10, ],"庞麦郎"], "ales", True]
del li[2:6]
print(li)
执行结果：
[1, 12, True]
8、in操作
作用：判断这个元素是否在列表中
ps1:
值存在这个列表中，就是Ture
li = [1, 12, 9, "age", ["刘正文", ["", 10, ],"庞麦郎"], "ales", True]
v = 1 in li #1在这个列表中，就是True
print(v)
True
ps2:
值不存在这个列表中，就是Flase
li = [1, 12, 9, "age", ["刘正文", ["", 10, ],"庞麦郎"], "ales", True]
v = 120 in li
print(v)
执行结果：
False
ps3:
因为在列表中的元素，以逗号做为分割，就是个整体，所以是Flase
li = [1, 12, 9, "age", ["史正文", ["", 10, ],"庞麦郎"], "ales", True]
#因为在列表中的元素，以逗号做为分割，就是个整体，所以是Flase
v = "刘正文" in li #史正文在第4个素引的列表中，所以是Flase
print(v)
执行结果：
False
9、操作
li = [1, 12, 9, "age", ["石振文", ["", 10], "庞麦郎"], "alex", True]
li[4][1][0][1] #索引取值，可以一直往里面找
补充知识：
只要我想把某个值，转成什么，就写上对应的类型，就可以进行转换
把字符串转成整型 a = ""
int(a)
a = 123
把整型转到字符串 a = 123
str(a)
10、转换
1、字符串转换列表 li = list("asdfasdfasdf"), 内部使用for循环
s = "pouaskdfauspdfiajsdkfj"
new_li = list(s)
print(new_li)
执行结果：
['p', 'o', 'u', 'a', 's', 'k', 'd', 'f', 'a', 'u', 's', 'p', 'd', 'f', 'i', 'a', 'j', 's', 'd', 'k', 'f', 'j']
2、列表转换成字符串
需要自己写for循环一个一个处理，即有数字又有符串
li = [11,22,33,"","alex"]
r = str(li) # 指的就是把上面列表打印出来
print(r)
执行结果：
[11, 22, 33, '', 'alex']
列表转换成字符串
li = [11,22,33,"","alex"]
s = ""
for i in li:
s = s + str(i)
print(s)
执行结果：
112233123alex
3、直接使用字符串join方法：列表中的元素只有字符串
li = ["","alex"]
v = "".join(li)
print(v)
执行结果：
123alex
4、补充：
1、字符串创建后，不可修改 replace:替换
v = "alex"
v = v.replace('l','el')
print(v)
执行结果：
aelex
2、列表
li = [11,22,33,44]
li[0]
li[0] = 999 s = "alex"
li[0]
s[0] = "E" li = [11,22,33,44]
print(li)
print(li)
print(li)
print(li)
print(li)
print(li)
print(li)
print(li)
列表，有序；元素可以被修改 列表
list
li = [111,22,33,44]
列表内容的总结：
1. 书写格式
tu = (111,"alex",(11,22),[(33,44)],True,33,44,)
一般写元组的时候，推荐在最后加入 ,
元素不可被修改，不能被增加或者删除 2. 索引
v = tu[0]
print(v) 3. 切片
v = tu[0:2]
print(v) 4. 可以被for循环，可迭代对象
for item in tu:
print(item) 5. 转换
s = "asdfasdf0"
li = ["asdf","asdfasdf"]
tu = ("asdf","asdf") v = tuple(s)
print(v) v = tuple(li)
print(v) v = list(tu)
print(v) v = "_".join(tu)
print(v) li = ["asdf","asdfasdf"]
li.extend((11,22,33,))
print(li) 6.元组的一级元素不可修改/删除/增加
tu = (111,"alex",(11,22),[(33,44)],True,33,44,) 元组，有序
v = tu[3][0][0]
print(v)
v=tu[3]
print(v)
tu[3][0] = 567
print(tu)
二、参数
1、追加 append
li = [11, 22, 33, 22, 44]
li.append(5)
li.append("alex")
li.append([1234,2323])
print(li)
执行结果：
[11, 22, 33, 22, 44, 5, 'alex', [1234, 2323]]
2、清空列表 clear
li = [11, 22, 33, 22, 44]
li.clear() #清空列表中的值
print(li)
执行结果：
[]
3、拷贝，浅拷贝 copy()
li = [11, 22, 33, 22, 44]
v = li.copy()
print(v)
print(li)
执行结果：
[11, 22, 33, 22, 44]
[11, 22, 33, 22, 44]
4、计算元素出现的次数 count
li = [11, 22, 33, 22, 44]
v = li.count(22) #统计22出现了几次，所以是2次
print(v)
执行结果：
2
5、扩展原列表，参数，可迭代对象 extend
li = [11, 22, 33, 22, 44]
li.extend([9898,"不得了"])
print(li)
执行结果：
[11, 22, 33, 22, 44, 9898, '不得了']
6、根据值获取当前值索引位置（左边优先） index
li = [11, , 33, 22, 44]
v = li.index(22) #从0开始数
print(v)
执行结果：
1
7、在指定索引位置插入元素 insert
li = [11, 22, 33, 22, 44]
li.insert(0,99)
print(li)
执行结果：
[99, 11, 22, 33, 22, 44]
8、删除某个值 pop
1.指定索引
2、默认最后一个，并获取删除的值
ps1:
li = [11, 22, 33, 22, 44]
v = li.pop()
print(li)
print(v)
执行结果：
[11, 22, 33, 22] #删除了44
44 #获取删除的值
ps2:
li = [11, 22, 33, 22, 44]
v = li.pop(1) #指定删除的参数，删除第1个，从0开始数
print(li)
print(v)
执行结果：
[11, 33, 22, 44]
22
9、删除列表中的指定值，左边优先 remove
PS:删除的命令一共有几个
pop、remove、del li[0]、del li[7:9]、clear
li = [11, 22, 33, 22, 44]
li.remove(22)
print(li)
执行结果：
[11, 33, 22, 44]
10、将当前列表进行翻转 reverse
li = [11, 22, 33, 22, 44]
li.reverse()
print(li)
执行结果：
[44, 22, 33, 22, 11]
11、列表的排序(从大到小） sort(reverse=True)
li = [11, 22, 33, 22, 44]
li.sort()
li.sort(reverse=True)
print(li)
执行结果：
[44, 33, 22, 22, 11]
12、enumrate
为一个可迭代的对象添加序号，可迭代的对象你可以理解成能用for循环的就是可迭代的。默认是编号是从0开始，可以设置从1开始
1 li = ["手机", "电脑", "鼠标垫", "游艇"]
2 for k, i in enumerate(li,1):
3 print(k,i)
执行结果
1 手机
2 电脑
3 鼠标垫
4 游艇
13、欠三个，以后再讲
cmp
key
sorted
三、元组
书写格式：()
1、元组的一级元素不可修改/删除/增加
ps1:
tu = (111, "alex", (11, 22), [(33, 44),9], True, 33, 44,)
#元组，有序
v = tu[3][0][0]
print(v)
执行结果：
33
ps2:
tu = (111, "alex", (11, 22), [(33, 44),9], True, 33, 44,)
v = tu[3] #从0开始数， " " （） [] 都只能算一个数
print(v)
执行结果：
[(33, 44), 9]
ps3:
列表可以被替换
tu = (111, "alex", (11, 22), [(33, 44)], True, 33, 44,)
tu[3][0] = 567 #获取到，列表可以被替换
print(tu)
执行结果：
(111, 'alex', (11, 22), [567], True, 33, 44)
2、列表和元组的使用说明：
什么时候用列表，什么时候用元组
可以被修改的就用list
不能被修改的就用元组
元组要修改的话，可以转成列表，再替换
四、字典（dict)
字典{}，列表[], 元组()
总结：
1、字典是以键值对的方式出现：key:value
2、字典的value的值可以是任何值
3、布尔值、列表、字典不能作为字典的key,但元组可以，做为列表的key
4、字典是无序的
书写格式：{}
1、基本结构，字典是以键值对的方式出现
info = {
"k1":"v1", #键值对
"k2":"v2"
}
“k1”:"v1" 表示为：key:value 前面是key,后面是值
2、字典的value（值）可以是任何值
info = {
"k1": 18,
"k2": True,
"k3": [
11,
[],
(),
22,
33,
{
'kk1': 'vv1',
'kk2': 'vv2',
'kk3': (11, 22),
}
],
"k4": (11, 22, 33, 44)
}
print(info)
执行结果：
{'k3': [11, [], (), 22, 33, {'kk1': 'vv1', 'kk2': 'vv2', 'kk3': (11, 22)}], 'k4': (11, 22, 33, 44), 'k1': 18, 'k2': True}
3、布尔值、列表、字典不能作为字典的key
ps1:
info ={
1: 'asdf',
"k1": 'asdf',
True: "", #布尔值不能作为字典的key，只能是值
}
print(info)
执行结果：
{1: '', 'k1': 'asdf'}
ps2:
info = {
1: 'asdf',
"k1": 'asdf',
True: "",
#[11,22]: 123 #列表不能做为字典的key，会报错。
(11,22): 123, #元组可以，做为列表的key
#{'k1':'v1'}: 123 #字典不可以做为字典的key("TypeError: unhashable type:'dict')
}
print(info)
执行结果：
{1: '', 'k1': 'asdf', (11, 22): 123}
4、字典无序
info = {
"k1": 18,
"k2": True,
"k3": [
11,
[],
(),
22,
33,
{
'kk1': 'vv1',
'kk2': 'vv2',
'kk3': (11, 22),
}
],
"k4": (11, 22, 33, 44)
}
print(info)
执行结果：
两次结果进行比较，会发现字典是无序的。
运行程序1次得出的结果：
{'k3': [11, [], (), 22, 33, {'kk1': 'vv1', 'kk3': (11, 22), 'kk2': 'vv2'}], 'k1': 18, 'k2': True, 'k4': (11, 22, 33, 44)}
再运行程序得出的结果：
{'k4': (11, 22, 33, 44), 'k3': [11, [], (), 22, 33, {'kk1': 'vv1', 'kk3': (11, 22), 'kk2': 'vv2'}], 'k1': 18, 'k2': True}
5、索引方式找到指定元素
ps1：
取18的值
info = {
"k1": 18,
2: True,
"k3": [
11,
[],
(),
22,
33,
{
'kk1': 'vv1',
'kk2': 'vv2',
'kk3': (11,22),
}
],
"k4": (11,22,33,44)
}
v = info['k1'] #获取key的值，就是18
print(v)
v = info[2] #获取2的值，就是True
print(v)
执行结果：
18
True
ps2:
找到11
info = {
"k1": 18,
2: True,
"k3": [
11,
[],
(),
22,
33,
{
'kk1': 'vv1',
'kk2': 'vv2',
'kk3': (11,22), #找到11
}
],
"k4": (11,22,33,44)
}
v = info['k3'][5]['kk3'][0] #找到11; 最后元组拿到第一个元素，加[0]
print(v)
执行结果：
11
6、字典支持 del 删除
ps1:
info = {
"k1": 18,
2: True,
"k3": [
11,
[],
(),
22,
33,
{
'kk1': 'vv1',
'kk2': 'vv2',
'kk3': (11,22),
}
],
"k4": (11,22,33,44)
}
del info['k1']
执行结果：
#删除掉了，所以什么都没有
ps2:
删除kk1
info = {
"k1": 18,
2: True,
"k3": [
11,
[],
(),
22,
33,
{
'kk1': 'vv1',
'kk2': 'vv2',
'kk3': (11,22),
}
],
"k4": (11,22,33,44)
}
del info['k3'][5]['kk1'] #删除'kk1': 'vv1',
print(info)
执行结果：
{'k1': 18, 'k3': [11, [], (), 22, 33, {'kk2': 'vv2', 'kk3': (11, 22)}], 2: True, 'k4': (11, 22, 33, 44)}
7、字典的for循环
ps1:
info = {
"k1": 18,
2: True,
"k3": [
11,
[],
(),
22,
33,
{
'kk1': 'vv1',
'kk2': 'vv2',
'kk3': (11,22),
}
],
"k4": (11,22,33,44)
}
for item in info:
print(item)
执行结果：
{2: True, 'k4': (11, 22, 33, 44), 'k3': [11, [], (), 22, 33, {'kk2': 'vv2', 'kk3': (11, 22)}], 'k1': 18}
2
k4
k3
k1
ps2:
dict里面的功能
info.keys() 默认循环他所有的key
info = {
"k1": 18,
2: True,
"k3": [
11,
[],
(),
22,
33,
{
'kk1': 'vv1',
'kk2': 'vv2',
'kk3': (11,22),
}
],
"k4": (11,22,33,44)
}
for item in info.keys():
print(item)
执行结果：
{'k4': (11, 22, 33, 44), 2: True, 'k3': [11, [], (), 22, 33, {'kk3': (11, 22), 'kk2': 'vv2'}], 'k1': 18}
k4
2
k3
k1
ps3:
循环他的values()
info = {
"k1": 18,
2: True,
"k3": [
11,
[],
(),
22,
33,
{
'kk1': 'vv1',
'kk2': 'vv2',
'kk3': (11,22),
}
],
"k4": (11,22,33,44)
}
for item in info.values():
print(item)
执行结果：
{2: True, 'k4': (11, 22, 33, 44), 'k1': 18, 'k3': [11, [], (), 22, 33, {'kk2': 'vv2', 'kk3': (11, 22)}]}
True
(11, 22, 33, 44)
18
[11, [], (), 22, 33, {'kk1': 'vv1', 'kk2': 'vv2', 'kk3': (11, 22)}]
ps4:
即想获取key，又想获取values
info = {
"k1": 18,
2: True,
"k3": [
11,
[],
(),
22,
33,
{
'kk1': 'vv1',
'kk2': 'vv2',
'kk3': (11,22),
}
],
"k4": (11,22,33,44)
}
for item in info.keys(): #即想获取key，又想获取values
print(item,info[item])
执行结果：
{'k4': (11, 22, 33, 44), 2: True, 'k3': [11, [], (), 22, 33, {'kk2': 'vv2', 'kk3': (11, 22)}], 'k1': 18}
k4 (11, 22, 33, 44)
2 True
k3 [11, [], (), 22, 33, {'kk2': 'vv2', 'kk1': 'vv1', 'kk3': (11, 22)}]
k1 18
ps5:
获取键值对
info = {
"k1": 18,
2: True,
"k3": [
11,
[],
(),
22,
33,
{
'kk1': 'vv1',
'kk2': 'vv2',
'kk3': (11,22),
}
],
"k4": (11,22,33,44)
}
for k,v in info.items():
print(k,v)
执行结果：
{'k1': 18, 2: True, 'k4': (11, 22, 33, 44), 'k3': [11, [], (), 22, 33, {'kk2': 'vv2', 'kk3': (11, 22)}]}
k1 18
2 True
k4 (11, 22, 33, 44)
k3 [11, [], (), 22, 33, {'kk2': 'vv2', 'kk1': 'vv1', 'kk3': (11, 22)}]
ps6:
True 1 False 0
info ={
"k1": 'asdf',
True: "",
# [11,22]: 123
(11,22): 123,
# {'k1':' v1'}: 123
}
print(info)
执行结果：
{True: '', 'k1': 'asdf', (11, 22): 123}
ps7: 打印序号,并取出key和value的值
#打印序号,并取出key和value的值
dic = {'k1':123,123:123,'':123}
for i,v ,in enumerate(dic.items(),1):
print(i,v[0],v[1]) for i,v in enumerate(dic,1):
print(i,v,dic[v])
复习字典：
字典:{},列表:[], 元组:()
总结：
1、字典key:value
2、字典的value的值可以是任何值
3、布尔值、列表、字典不能作为字典的key,但元组可以，做为列表的key
4、字典是无序的
一、字典的增加，删除，修改，查询
示例：
info={'nulige': 28, 'alex': 30, 'liuyang': 'man', 'wusir': 'woman'}
1、增加和修改
增加key和vlaue
#修改value
info['nulige']=18
print(info) #增加
info.update({'sunkai':18})
print(info) #增加key和vlaue(没有就增加，有就修改）
info['lihuafen']=35
print(info)
往字典的列表中加入元 素
#往wusir字典中加入一个元素44
info={'nulige': 28, 'alex': 30, 'liuyang': 'man', 'wusir': [11,22,33]}
info['wusir'].append(44)
print(info)
#往wusir字典的第一个位置插入个元素18
info={'nulige': 28, 'alex': 30, 'liuyang': 'man', 'wusir': [11,22,33]}
info['wusir'].insert(0,44)
print(info)
2、删除
#删除
del info['nulige']
print(info) #删除
info.pop('alex')
print(info) #清空字典
info.clear()
print(info) #{}
3、查询
获取字典的key和values
#取字典的key #法1：
for item in info:
print(item) #法2：
for item in info.keys():
print(item) #取字典的values
for item in info.values():
print(item) #取key和values
for item in info.keys():
print(item,info[item])
4、获取字典键值对应的值
for k,v in info.items():
print(k,v) #结果：
nulige 28
alex 30
wusir woman
liuyang man
5、打印序号，取key和value
info={'nulige': 28, 'alex': 30, 'liuyang': 'man', 'wusir': 'woman'}
法一：
for i,v,in enumerate(info.items(),1):
print(i,v[0],v[1])
法二：
for i,v in enumerate(info,1):
print(i,v,info[v])
执行结果：
1 nulige 28
2 alex 30
3 wusir woman
4 liuyang man
6、计算字典总个数
info={'nulige': 28, 'alex': 30, 'liuyang': 'man', 'wusir': 'woman'}
print(len(info))
#执行结果：
4
五、整理必须掌握的东西
一、数字
int(..) 二、字符串
replace/find/join/strip/startswith/split/upper/lower/format
tempalte = "i am {name}, age : {age}"
# v = tempalte.format(name='alex',age=19)
v = tempalte.format(**{"name": 'alex','age': 19})
print(v) 三、列表
append、extend、insert
索引、切片、循环 四、元组
忽略
索引、切片、循环 以及元素不能被修改 五、字典
get/update/keys/values/items
for,索引 dic = {
"k1": 'v1'
} v = "k1" in dic
print(v) v = "v1" in dic.values()
print(v) 六、布尔值
0 1
bool(...)
None "" () [] {} 0 ==> False
基本数据类型-列表_元组_字典_day4的更多相关文章
- Pyhton编程（五）之基本数据类型-列表、元组、字典
一:列表(list) 列表是由一系列按特定顺序排列的元素组成,可以创建包含字母表中的所有字母.数字.或中文的列表,也可以将任何东西加入列表中,其中的元素之间可以没有任何关系. 在Python中,用方括 ...
- 三、python的数据类型 列表、元组、字典
1.list 列表 列表是由一序列特定顺序排列的元素组成的.可以把字符串,数字,字典等都可以任何东西加入到列表中,列表中的元素之间没有任何关系.列表也是自带下标的,默认也还是从0开始. List常用的 ...
- Python基本数据类型--列表、元组、字典、集合
一.Python基本数据类型--列表(List) 1.定义:[ ]内以逗号分隔,按照索引,存放各种数据类型,每个位置代表一个元素. 2.列表的创建: # 方式一 list1 = ['name','ag ...
- Python之路(第四篇)：Python基本数据类型列表、元组、字典
一.列表 1.列表 list ,是一个类,li = [1,2,"nicholas"] li是通过list类创建的对象. 2.list特点: 用中括号括起来,用逗号分割每个元素,列表 ...
- 第三节 Python基础之数据类型(列表，元组，字典)
列表,简单说就是用[]括起来的一大堆数据,这些数据我们叫做元素,元素与元素之间用","隔开,这些元素可以是数字,布尔值,字符串,列表等等,基本所有的数据类型都可以放在列表里边,同时 ...
- 基本数据类型-集合(set)_上周内容回顾（字符串_数字_列表_元组_字典_集合）
上周内容回顾 1.字符串 2.数字 除了布尔类型外,int.long.float和complex都可以使用的运算为:加.减.乘.除.整除.幂运算和取余 3.列表和元组 列表的内容可变,可以包含任意对象 ...
- python基础（3）_列表、元组、字典
一.列表 定义:[ ] 内以逗号分隔,按照索引,存放各种数据类型,每个位置代表一个元素 特性: > 可存放多个值 > 可修改指定索引位置对应的值,可变 > 按照从左到右的顺序定义列表 ...
- 【笔记】Python基础一 ：变量，控制结构，运算符及数据类型之数字，字符串，列表，元组，字典
一,开发语言介绍 高级语言:Java,C#,Python ==>产生字节码 低级语言:C,汇编 ==>产生机器码 高级语言开发效率高,低级语言运行效率 ...
- python-字符编码、字符串格式化、进制转化、数据类型、列表、元组、字典总结
目录: 一.字符编码 二.字符串格式化 三.进制转换 四.数据类型及其操作 五.字符串转换 六.列表 七.元组 八.字典 一.字符编码: 计算机由美国人发明,最早的字符编码为ASCII,只规定了英文字 ...
- python基础知识3——基本的数据类型2——列表，元组，字典，集合
磨人的小妖精们啊!终于可以归置下自己的大脑啦,在这里我要把--整型,长整型,浮点型,字符串,列表,元组,字典,集合,这几个知识点特别多的东西,统一的捯饬捯饬,不然一直脑袋里面乱乱的. 一.列表 1.列 ...
随机推荐
- C语言中链表任意位置怎么插入数据？然后写入文件中？
链表插入示意图:(图是个人所画)因为链表指针指来指去,难以理解,所以辅助画图更加方便. 插入某个学号后面图: 定义的结构体: struct student { ]; //学生学号 ]; //学生姓名 ...
- Server Tomcat v7.0 Server at localhost failed to start.临时解决办法
错误名:Server Tomcat v7.0 Server at localhost failed to start. 解决办法:去掉下面这句话: (通常在代码开头部分,public class前) ...
- 连载《一个程序猿的生命周期》-6、自学C++，二级考过后，为工作的机会打下了基础
一个程序猿的生命周期 微信平台 口 号:职业交流,职业规划:面对现实,用心去交流.感悟. 公众号:iterlifetime 百木-ITer职业交流奋斗 群:141588103 微 博:h ...
- OAuth2授权原理
最近在做第三方接入的,初步定下使用OAuth2协议,花了些时间对OAuth2的授权方式做了些了解. 我还记得一两年前,跟一位同事聊起互联网时,当时我说过一个想法: 目前不少较为稀有的资源,很多都是论坛 ...
- android ndk 无法找到 so 案例一例
代码如下: public class JNIWrapWorkerThread{ static { System.loadLibrary("libjni_base_fram ...
- IOS
网上课程:http://www.zhijieketang.com/ edu.51cto.com 码云:http://git.oschina.net/名字 Gesture:https://www.osc ...
- Spring JPA Junit 关闭自动回滚
因为用了JPA配合Hibernate ,采用注解默认是开启了LayzLoad也就是懒加载,所以不得不在Junit的单元测试上加上@Transactional注解 这样Spring会自动为当前线程开启S ...
- HTML 学习笔记 CSS样式（定位）
CSS定位(Positioning)属性 允许你对元素进行定位. CSS定位和浮动 CSS为定位和浮动提供了一些属性,利用这些属性 可以建立列式布局,将布局的一部分与另一部分重叠.还可以完成多年来通常 ...
- 转- android硬件传感器
纯属转载:http://dev.10086.cn/cmdn/bbs/thread-41843-1-1.html 1.传感器入门 自从苹果公司在2007年发布第一代iPhone以来,以前看似和手机挨不着 ...
- web app iphone4 iphone5 iphone6 iphone6 Plus响应式布局 适配代码
来源:http://www.phptext.net/article_view.php?id=387 -------------------------------------------------- ...